From e7dc5c0939d30ccba98418c42799c4e39f646d23 Mon Sep 17 00:00:00 2001 From: Dario Nieuwenhuis Date: Mon, 7 Jun 2021 00:10:54 +0200 Subject: [PATCH] fmt: make all macros `macro_rules` so scoping is consistent. --- embassy-extras/src/fmt.rs | 213 +++++++++++++++++++++-------- embassy-extras/src/ring_buffer.rs | 2 - embassy-net/src/config/dhcp.rs | 1 - embassy-net/src/config/mod.rs | 1 - embassy-net/src/config/statik.rs | 1 - embassy-net/src/device.rs | 1 - embassy-net/src/fmt.rs | 217 +++++++++++++++++++++--------- embassy-net/src/stack.rs | 1 - embassy-net/src/tcp_socket.rs | 1 - embassy-nrf/src/buffered_uarte.rs | 1 - embassy-nrf/src/fmt.rs | 213 +++++++++++++++++++++-------- embassy-nrf/src/pwm.rs | 1 - embassy-nrf/src/qspi.rs | 1 - embassy-nrf/src/spim.rs | 2 +- embassy-nrf/src/twim.rs | 2 +- embassy-nrf/src/uarte.rs | 1 - embassy-rp/src/dma.rs | 1 - embassy-rp/src/fmt.rs | 217 +++++++++++++++++++++--------- embassy-rp/src/pll.rs | 1 - embassy-stm32/src/dac/v2.rs | 1 - embassy-stm32/src/dma/v2.rs | 1 - embassy-stm32/src/fmt.rs | 213 +++++++++++++++++++++-------- embassy-stm32/src/rcc/h7/mod.rs | 1 - embassy-stm32/src/rcc/h7/pll.rs | 1 - embassy-stm32/src/sdmmc/v2.rs | 7 +- embassy/src/executor/mod.rs | 1 - embassy/src/executor/waker.rs | 4 +- embassy/src/fmt.rs | 213 +++++++++++++++++++++-------- embassy/src/time/mod.rs | 2 - embassy/src/util/drop_bomb.rs | 1 - embassy/src/util/mutex.rs | 2 - embassy/src/util/portal.rs | 1 - embassy/src/util/signal.rs | 1 - 33 files changed, 950 insertions(+), 377 deletions(-) diff --git a/embassy-extras/src/fmt.rs b/embassy-extras/src/fmt.rs index 160642ccd..6c5063f7c 100644 --- a/embassy-extras/src/fmt.rs +++ b/embassy-extras/src/fmt.rs @@ -1,69 +1,170 @@ #![macro_use] -#![allow(clippy::module_inception)] -#![allow(unused)] +#![allow(unused_macros)] #[cfg(all(feature = "defmt", feature = "log"))] compile_error!("You may not enable both `defmt` and `log` features."); -pub use fmt::*; +macro_rules! assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert!($($x)*); + } + }; +} + +macro_rules! assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_eq!($($x)*); + } + }; +} + +macro_rules! assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_ne!($($x)*); + } + }; +} + +macro_rules! debug_assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert!($($x)*); + } + }; +} + +macro_rules! debug_assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_eq!($($x)*); + } + }; +} + +macro_rules! debug_assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_ne!($($x)*); + } + }; +} + +macro_rules! todo { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::todo!($($x)*); + #[cfg(feature = "defmt")] + defmt::todo!($($x)*); + } + }; +} + +macro_rules! unreachable { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::unreachable!($($x)*); + #[cfg(feature = "defmt")] + defmt::unreachable!($($x)*); + } + }; +} + +macro_rules! panic { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::panic!($($x)*); + #[cfg(feature = "defmt")] + defmt::panic!($($x)*); + } + }; +} + +macro_rules! trace { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::trace!($($x)*); + #[cfg(feature = "defmt")] + defmt::trace!($($x)*); + } + }; +} + +macro_rules! debug { + ($($x:tt)*) => { + { + #[cfg(fevature = "log")] + log::debug!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug!($($x)*); + } + }; +} + +macro_rules! info { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::info!($($x)*); + #[cfg(feature = "defmt")] + defmt::info!($($x)*); + } + }; +} + +macro_rules! warn { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::warn!($($x)*); + #[cfg(feature = "defmt")] + defmt::warn!($($x)*); + } + }; +} + +macro_rules! error { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::error!($($x)*); + #[cfg(feature = "defmt")] + defmt::error!($($x)*); + } + }; +} #[cfg(feature = "defmt")] -mod fmt { - pub use defmt::{ - assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error, - info, panic, todo, trace, unreachable, unwrap, warn, +macro_rules! unwrap { + ($($x:tt)*) => { + defmt::unwrap!($($x)*) }; } -#[cfg(feature = "log")] -mod fmt { - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - pub use log::{debug, error, info, trace, warn}; -} - -#[cfg(not(any(feature = "defmt", feature = "log")))] -mod fmt { - #![macro_use] - - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - - macro_rules! trace { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! debug { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! info { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! warn { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! error { - ($($msg:expr),+ $(,)?) => { - () - }; - } -} - #[cfg(not(feature = "defmt"))] macro_rules! unwrap { ($arg:expr) => { diff --git a/embassy-extras/src/ring_buffer.rs b/embassy-extras/src/ring_buffer.rs index dafdd958a..18795787f 100644 --- a/embassy-extras/src/ring_buffer.rs +++ b/embassy-extras/src/ring_buffer.rs @@ -1,5 +1,3 @@ -use crate::fmt::assert; - pub struct RingBuffer<'a> { buf: &'a mut [u8], start: usize, diff --git a/embassy-net/src/config/dhcp.rs b/embassy-net/src/config/dhcp.rs index f0c144321..8bbcd8176 100644 --- a/embassy-net/src/config/dhcp.rs +++ b/embassy-net/src/config/dhcp.rs @@ -4,7 +4,6 @@ use smoltcp::time::Instant; use super::*; use crate::device::LinkState; -use crate::fmt::*; use crate::{Interface, SocketSet}; pub struct DhcpConfigurator { diff --git a/embassy-net/src/config/mod.rs b/embassy-net/src/config/mod.rs index 94725dba6..0f1886ae8 100644 --- a/embassy-net/src/config/mod.rs +++ b/embassy-net/src/config/mod.rs @@ -2,7 +2,6 @@ use heapless::Vec; use smoltcp::time::Instant; use smoltcp::wire::{Ipv4Address, Ipv4Cidr}; -use crate::fmt::*; use crate::{Interface, SocketSet}; mod statik; diff --git a/embassy-net/src/config/statik.rs b/embassy-net/src/config/statik.rs index 912143bff..9a530717b 100644 --- a/embassy-net/src/config/statik.rs +++ b/embassy-net/src/config/statik.rs @@ -1,7 +1,6 @@ use smoltcp::time::Instant; use super::*; -use crate::fmt::*; use crate::{Interface, SocketSet}; pub struct StaticConfigurator { diff --git a/embassy-net/src/device.rs b/embassy-net/src/device.rs index 6c06b0605..5fcb94ac8 100644 --- a/embassy-net/src/device.rs +++ b/embassy-net/src/device.rs @@ -3,7 +3,6 @@ use smoltcp::phy::Device as SmolDevice; use smoltcp::phy::DeviceCapabilities; use smoltcp::time::Instant as SmolInstant; -use crate::fmt::*; use crate::packet_pool::PacketBoxExt; use crate::Result; use crate::{Packet, PacketBox, PacketBuf}; diff --git a/embassy-net/src/fmt.rs b/embassy-net/src/fmt.rs index 4da69766c..6c5063f7c 100644 --- a/embassy-net/src/fmt.rs +++ b/embassy-net/src/fmt.rs @@ -1,74 +1,171 @@ #![macro_use] +#![allow(unused_macros)] #[cfg(all(feature = "defmt", feature = "log"))] compile_error!("You may not enable both `defmt` and `log` features."); -pub use fmt::*; +macro_rules! assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert!($($x)*); + } + }; +} + +macro_rules! assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_eq!($($x)*); + } + }; +} + +macro_rules! assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_ne!($($x)*); + } + }; +} + +macro_rules! debug_assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert!($($x)*); + } + }; +} + +macro_rules! debug_assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_eq!($($x)*); + } + }; +} + +macro_rules! debug_assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_ne!($($x)*); + } + }; +} + +macro_rules! todo { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::todo!($($x)*); + #[cfg(feature = "defmt")] + defmt::todo!($($x)*); + } + }; +} + +macro_rules! unreachable { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::unreachable!($($x)*); + #[cfg(feature = "defmt")] + defmt::unreachable!($($x)*); + } + }; +} + +macro_rules! panic { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::panic!($($x)*); + #[cfg(feature = "defmt")] + defmt::panic!($($x)*); + } + }; +} + +macro_rules! trace { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::trace!($($x)*); + #[cfg(feature = "defmt")] + defmt::trace!($($x)*); + } + }; +} + +macro_rules! debug { + ($($x:tt)*) => { + { + #[cfg(fevature = "log")] + log::debug!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug!($($x)*); + } + }; +} + +macro_rules! info { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::info!($($x)*); + #[cfg(feature = "defmt")] + defmt::info!($($x)*); + } + }; +} + +macro_rules! warn { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::warn!($($x)*); + #[cfg(feature = "defmt")] + defmt::warn!($($x)*); + } + }; +} + +macro_rules! error { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::error!($($x)*); + #[cfg(feature = "defmt")] + defmt::error!($($x)*); + } + }; +} #[cfg(feature = "defmt")] -mod fmt { - pub use defmt::{ - assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error, - info, panic, todo, trace, unreachable, unwrap, warn, +macro_rules! unwrap { + ($($x:tt)*) => { + defmt::unwrap!($($x)*) }; } -#[cfg(feature = "log")] -mod fmt { - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - pub use log::{debug, error, info, trace, warn}; -} - -#[cfg(not(any(feature = "defmt", feature = "log")))] -mod fmt { - #![macro_use] - - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - - #[macro_export] - macro_rules! trace { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - #[macro_export] - macro_rules! debug { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - #[macro_export] - macro_rules! info { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - #[macro_export] - macro_rules! warn { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - #[macro_export] - macro_rules! error { - ($($msg:expr),+ $(,)?) => { - () - }; - } -} - #[cfg(not(feature = "defmt"))] -#[macro_export] macro_rules! unwrap { ($arg:expr) => { match $crate::fmt::Try::into_result($arg) { diff --git a/embassy-net/src/stack.rs b/embassy-net/src/stack.rs index e436beb1e..a38f00958 100644 --- a/embassy-net/src/stack.rs +++ b/embassy-net/src/stack.rs @@ -20,7 +20,6 @@ use smoltcp::wire::{IpAddress, IpCidr, Ipv4Address, Ipv4Cidr}; use crate::config::Configurator; use crate::config::Event; use crate::device::{Device, DeviceAdapter, LinkState}; -use crate::fmt::*; use crate::{Interface, SocketSet}; const ADDRESSES_LEN: usize = 1; diff --git a/embassy-net/src/tcp_socket.rs b/embassy-net/src/tcp_socket.rs index 4f43bc611..def4c8176 100644 --- a/embassy-net/src/tcp_socket.rs +++ b/embassy-net/src/tcp_socket.rs @@ -11,7 +11,6 @@ use smoltcp::time::Duration; use smoltcp::wire::IpEndpoint; use super::stack::Stack; -use crate::fmt::*; use crate::{Error, Result}; pub struct TcpSocket<'a> { diff --git a/embassy-nrf/src/buffered_uarte.rs b/embassy-nrf/src/buffered_uarte.rs index b4ec70913..d853bda73 100644 --- a/embassy-nrf/src/buffered_uarte.rs +++ b/embassy-nrf/src/buffered_uarte.rs @@ -11,7 +11,6 @@ use embassy_extras::peripheral::{PeripheralMutex, PeripheralState}; use embassy_extras::ring_buffer::RingBuffer; use embassy_extras::{low_power_wait_until, unborrow}; -use crate::fmt::{panic, *}; use crate::gpio::sealed::Pin as _; use crate::gpio::{OptionalPin as GpioOptionalPin, Pin as GpioPin}; use crate::pac; diff --git a/embassy-nrf/src/fmt.rs b/embassy-nrf/src/fmt.rs index 160642ccd..6c5063f7c 100644 --- a/embassy-nrf/src/fmt.rs +++ b/embassy-nrf/src/fmt.rs @@ -1,69 +1,170 @@ #![macro_use] -#![allow(clippy::module_inception)] -#![allow(unused)] +#![allow(unused_macros)] #[cfg(all(feature = "defmt", feature = "log"))] compile_error!("You may not enable both `defmt` and `log` features."); -pub use fmt::*; +macro_rules! assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert!($($x)*); + } + }; +} + +macro_rules! assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_eq!($($x)*); + } + }; +} + +macro_rules! assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_ne!($($x)*); + } + }; +} + +macro_rules! debug_assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert!($($x)*); + } + }; +} + +macro_rules! debug_assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_eq!($($x)*); + } + }; +} + +macro_rules! debug_assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_ne!($($x)*); + } + }; +} + +macro_rules! todo { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::todo!($($x)*); + #[cfg(feature = "defmt")] + defmt::todo!($($x)*); + } + }; +} + +macro_rules! unreachable { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::unreachable!($($x)*); + #[cfg(feature = "defmt")] + defmt::unreachable!($($x)*); + } + }; +} + +macro_rules! panic { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::panic!($($x)*); + #[cfg(feature = "defmt")] + defmt::panic!($($x)*); + } + }; +} + +macro_rules! trace { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::trace!($($x)*); + #[cfg(feature = "defmt")] + defmt::trace!($($x)*); + } + }; +} + +macro_rules! debug { + ($($x:tt)*) => { + { + #[cfg(fevature = "log")] + log::debug!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug!($($x)*); + } + }; +} + +macro_rules! info { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::info!($($x)*); + #[cfg(feature = "defmt")] + defmt::info!($($x)*); + } + }; +} + +macro_rules! warn { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::warn!($($x)*); + #[cfg(feature = "defmt")] + defmt::warn!($($x)*); + } + }; +} + +macro_rules! error { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::error!($($x)*); + #[cfg(feature = "defmt")] + defmt::error!($($x)*); + } + }; +} #[cfg(feature = "defmt")] -mod fmt { - pub use defmt::{ - assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error, - info, panic, todo, trace, unreachable, unwrap, warn, +macro_rules! unwrap { + ($($x:tt)*) => { + defmt::unwrap!($($x)*) }; } -#[cfg(feature = "log")] -mod fmt { - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - pub use log::{debug, error, info, trace, warn}; -} - -#[cfg(not(any(feature = "defmt", feature = "log")))] -mod fmt { - #![macro_use] - - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - - macro_rules! trace { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! debug { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! info { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! warn { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! error { - ($($msg:expr),+ $(,)?) => { - () - }; - } -} - #[cfg(not(feature = "defmt"))] macro_rules! unwrap { ($arg:expr) => { diff --git a/embassy-nrf/src/pwm.rs b/embassy-nrf/src/pwm.rs index 8fc16a3ba..07509aef9 100644 --- a/embassy-nrf/src/pwm.rs +++ b/embassy-nrf/src/pwm.rs @@ -6,7 +6,6 @@ use core::sync::atomic::{compiler_fence, Ordering}; use embassy::util::Unborrow; use embassy_extras::unborrow; -use crate::fmt::{unreachable, *}; use crate::gpio::sealed::Pin as _; use crate::gpio::OptionalPin as GpioOptionalPin; use crate::interrupt::Interrupt; diff --git a/embassy-nrf/src/qspi.rs b/embassy-nrf/src/qspi.rs index 882db9d8b..42bf8f419 100644 --- a/embassy-nrf/src/qspi.rs +++ b/embassy-nrf/src/qspi.rs @@ -10,7 +10,6 @@ use embassy::util::{AtomicWaker, DropBomb, Unborrow}; use embassy_extras::unborrow; use futures::future::poll_fn; -use crate::fmt::{assert, assert_eq, *}; use crate::gpio::sealed::Pin as _; use crate::gpio::{self, Pin as GpioPin}; use crate::pac; diff --git a/embassy-nrf/src/spim.rs b/embassy-nrf/src/spim.rs index b5e9afbc1..47d7c5f90 100644 --- a/embassy-nrf/src/spim.rs +++ b/embassy-nrf/src/spim.rs @@ -11,10 +11,10 @@ use embassy_extras::unborrow; use futures::future::poll_fn; use traits::spi::FullDuplex; +use crate::gpio; use crate::gpio::sealed::Pin as _; use crate::gpio::{OptionalPin, Pin as GpioPin}; use crate::interrupt::Interrupt; -use crate::{fmt::*, gpio}; use crate::{pac, util::slice_in_ram_or}; pub use embedded_hal::spi::{Mode, Phase, Polarity, MODE_0, MODE_1, MODE_2, MODE_3}; diff --git a/embassy-nrf/src/twim.rs b/embassy-nrf/src/twim.rs index 160868d7d..5f3c51578 100644 --- a/embassy-nrf/src/twim.rs +++ b/embassy-nrf/src/twim.rs @@ -18,10 +18,10 @@ use futures::future::poll_fn; use traits::i2c::I2c; use crate::chip::{EASY_DMA_SIZE, FORCE_COPY_BUFFER_SIZE}; +use crate::gpio; use crate::gpio::Pin as GpioPin; use crate::pac; use crate::util::{slice_in_ram, slice_in_ram_or}; -use crate::{fmt::*, gpio}; pub enum Frequency { #[doc = "26738688: 100 kbps"] diff --git a/embassy-nrf/src/uarte.rs b/embassy-nrf/src/uarte.rs index 2f6d1a391..de093c7f0 100644 --- a/embassy-nrf/src/uarte.rs +++ b/embassy-nrf/src/uarte.rs @@ -13,7 +13,6 @@ use embassy_extras::unborrow; use futures::future::poll_fn; use crate::chip::EASY_DMA_SIZE; -use crate::fmt::{assert, panic, *}; use crate::gpio::sealed::Pin as _; use crate::gpio::{self, OptionalPin as GpioOptionalPin, Pin as GpioPin}; use crate::interrupt::Interrupt; diff --git a/embassy-rp/src/dma.rs b/embassy-rp/src/dma.rs index a74b9b92b..235e92d7c 100644 --- a/embassy-rp/src/dma.rs +++ b/embassy-rp/src/dma.rs @@ -1,6 +1,5 @@ use core::sync::atomic::{compiler_fence, Ordering}; -use crate::fmt::assert; use crate::pac::dma::vals; use crate::{pac, peripherals}; diff --git a/embassy-rp/src/fmt.rs b/embassy-rp/src/fmt.rs index 4da69766c..6c5063f7c 100644 --- a/embassy-rp/src/fmt.rs +++ b/embassy-rp/src/fmt.rs @@ -1,74 +1,171 @@ #![macro_use] +#![allow(unused_macros)] #[cfg(all(feature = "defmt", feature = "log"))] compile_error!("You may not enable both `defmt` and `log` features."); -pub use fmt::*; +macro_rules! assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert!($($x)*); + } + }; +} + +macro_rules! assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_eq!($($x)*); + } + }; +} + +macro_rules! assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_ne!($($x)*); + } + }; +} + +macro_rules! debug_assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert!($($x)*); + } + }; +} + +macro_rules! debug_assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_eq!($($x)*); + } + }; +} + +macro_rules! debug_assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_ne!($($x)*); + } + }; +} + +macro_rules! todo { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::todo!($($x)*); + #[cfg(feature = "defmt")] + defmt::todo!($($x)*); + } + }; +} + +macro_rules! unreachable { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::unreachable!($($x)*); + #[cfg(feature = "defmt")] + defmt::unreachable!($($x)*); + } + }; +} + +macro_rules! panic { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::panic!($($x)*); + #[cfg(feature = "defmt")] + defmt::panic!($($x)*); + } + }; +} + +macro_rules! trace { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::trace!($($x)*); + #[cfg(feature = "defmt")] + defmt::trace!($($x)*); + } + }; +} + +macro_rules! debug { + ($($x:tt)*) => { + { + #[cfg(fevature = "log")] + log::debug!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug!($($x)*); + } + }; +} + +macro_rules! info { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::info!($($x)*); + #[cfg(feature = "defmt")] + defmt::info!($($x)*); + } + }; +} + +macro_rules! warn { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::warn!($($x)*); + #[cfg(feature = "defmt")] + defmt::warn!($($x)*); + } + }; +} + +macro_rules! error { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::error!($($x)*); + #[cfg(feature = "defmt")] + defmt::error!($($x)*); + } + }; +} #[cfg(feature = "defmt")] -mod fmt { - pub use defmt::{ - assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error, - info, panic, todo, trace, unreachable, unwrap, warn, +macro_rules! unwrap { + ($($x:tt)*) => { + defmt::unwrap!($($x)*) }; } -#[cfg(feature = "log")] -mod fmt { - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - pub use log::{debug, error, info, trace, warn}; -} - -#[cfg(not(any(feature = "defmt", feature = "log")))] -mod fmt { - #![macro_use] - - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - - #[macro_export] - macro_rules! trace { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - #[macro_export] - macro_rules! debug { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - #[macro_export] - macro_rules! info { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - #[macro_export] - macro_rules! warn { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - #[macro_export] - macro_rules! error { - ($($msg:expr),+ $(,)?) => { - () - }; - } -} - #[cfg(not(feature = "defmt"))] -#[macro_export] macro_rules! unwrap { ($arg:expr) => { match $crate::fmt::Try::into_result($arg) { diff --git a/embassy-rp/src/pll.rs b/embassy-rp/src/pll.rs index befb368c5..13c16baf8 100644 --- a/embassy-rp/src/pll.rs +++ b/embassy-rp/src/pll.rs @@ -1,4 +1,3 @@ -use crate::fmt::assert; use crate::pac; const XOSC_MHZ: u32 = 12; diff --git a/embassy-stm32/src/dac/v2.rs b/embassy-stm32/src/dac/v2.rs index a7aad04f0..d8c9415b6 100644 --- a/embassy-stm32/src/dac/v2.rs +++ b/embassy-stm32/src/dac/v2.rs @@ -1,5 +1,4 @@ use crate::dac::{DacPin, Instance}; -use crate::fmt::*; use crate::gpio::AnyPin; use crate::pac::dac; use core::marker::PhantomData; diff --git a/embassy-stm32/src/dma/v2.rs b/embassy-stm32/src/dma/v2.rs index 5b2505463..e7bd69130 100644 --- a/embassy-stm32/src/dma/v2.rs +++ b/embassy-stm32/src/dma/v2.rs @@ -5,7 +5,6 @@ use embassy::util::AtomicWaker; use futures::future::poll_fn; use super::*; -use crate::fmt::assert; use crate::interrupt; use crate::pac; use crate::pac::dma::{regs, vals}; diff --git a/embassy-stm32/src/fmt.rs b/embassy-stm32/src/fmt.rs index 160642ccd..6c5063f7c 100644 --- a/embassy-stm32/src/fmt.rs +++ b/embassy-stm32/src/fmt.rs @@ -1,69 +1,170 @@ #![macro_use] -#![allow(clippy::module_inception)] -#![allow(unused)] +#![allow(unused_macros)] #[cfg(all(feature = "defmt", feature = "log"))] compile_error!("You may not enable both `defmt` and `log` features."); -pub use fmt::*; +macro_rules! assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert!($($x)*); + } + }; +} + +macro_rules! assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_eq!($($x)*); + } + }; +} + +macro_rules! assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_ne!($($x)*); + } + }; +} + +macro_rules! debug_assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert!($($x)*); + } + }; +} + +macro_rules! debug_assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_eq!($($x)*); + } + }; +} + +macro_rules! debug_assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_ne!($($x)*); + } + }; +} + +macro_rules! todo { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::todo!($($x)*); + #[cfg(feature = "defmt")] + defmt::todo!($($x)*); + } + }; +} + +macro_rules! unreachable { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::unreachable!($($x)*); + #[cfg(feature = "defmt")] + defmt::unreachable!($($x)*); + } + }; +} + +macro_rules! panic { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::panic!($($x)*); + #[cfg(feature = "defmt")] + defmt::panic!($($x)*); + } + }; +} + +macro_rules! trace { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::trace!($($x)*); + #[cfg(feature = "defmt")] + defmt::trace!($($x)*); + } + }; +} + +macro_rules! debug { + ($($x:tt)*) => { + { + #[cfg(fevature = "log")] + log::debug!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug!($($x)*); + } + }; +} + +macro_rules! info { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::info!($($x)*); + #[cfg(feature = "defmt")] + defmt::info!($($x)*); + } + }; +} + +macro_rules! warn { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::warn!($($x)*); + #[cfg(feature = "defmt")] + defmt::warn!($($x)*); + } + }; +} + +macro_rules! error { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::error!($($x)*); + #[cfg(feature = "defmt")] + defmt::error!($($x)*); + } + }; +} #[cfg(feature = "defmt")] -mod fmt { - pub use defmt::{ - assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error, - info, panic, todo, trace, unreachable, unwrap, warn, +macro_rules! unwrap { + ($($x:tt)*) => { + defmt::unwrap!($($x)*) }; } -#[cfg(feature = "log")] -mod fmt { - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - pub use log::{debug, error, info, trace, warn}; -} - -#[cfg(not(any(feature = "defmt", feature = "log")))] -mod fmt { - #![macro_use] - - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - - macro_rules! trace { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! debug { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! info { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! warn { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! error { - ($($msg:expr),+ $(,)?) => { - () - }; - } -} - #[cfg(not(feature = "defmt"))] macro_rules! unwrap { ($arg:expr) => { diff --git a/embassy-stm32/src/rcc/h7/mod.rs b/embassy-stm32/src/rcc/h7/mod.rs index fbf864bf6..57cdd5470 100644 --- a/embassy-stm32/src/rcc/h7/mod.rs +++ b/embassy-stm32/src/rcc/h7/mod.rs @@ -2,7 +2,6 @@ use core::marker::PhantomData; use embassy::util::Unborrow; -use crate::fmt::{assert, panic}; use crate::pac::rcc::vals::Timpre; use crate::pac::{DBGMCU, RCC, SYSCFG}; use crate::peripherals; diff --git a/embassy-stm32/src/rcc/h7/pll.rs b/embassy-stm32/src/rcc/h7/pll.rs index af958d093..4c40d84d4 100644 --- a/embassy-stm32/src/rcc/h7/pll.rs +++ b/embassy-stm32/src/rcc/h7/pll.rs @@ -1,5 +1,4 @@ use super::{Hertz, RCC}; -use crate::fmt::assert; const VCO_MIN: u32 = 150_000_000; const VCO_MAX: u32 = 420_000_000; diff --git a/embassy-stm32/src/sdmmc/v2.rs b/embassy-stm32/src/sdmmc/v2.rs index 2c7f8ac00..9c7bad4df 100644 --- a/embassy-stm32/src/sdmmc/v2.rs +++ b/embassy-stm32/src/sdmmc/v2.rs @@ -10,7 +10,6 @@ use embassy_extras::unborrow; use futures::future::poll_fn; use sdio_host::{BusWidth, CardCapacity, CardStatus, CurrentState, SDStatus, CID, CSD, OCR, SCR}; -use crate::fmt::*; use crate::interrupt::Interrupt; use crate::pac; use crate::pac::gpio::Gpio; @@ -434,7 +433,7 @@ impl SdmmcInner { BusWidth::One => 0, BusWidth::Four => 1, BusWidth::Eight => 2, - _ => self::panic!("Invalid Bus Width"), + _ => panic!("Invalid Bus Width"), }) }); @@ -637,7 +636,7 @@ impl SdmmcInner { direction: Dir, data_transfer_timeout: u32, ) { - self::assert!(block_size <= 14, "Block size up to 2^14 bytes"); + assert!(block_size <= 14, "Block size up to 2^14 bytes"); let regs = self.0; let dtdir = match direction { @@ -678,7 +677,7 @@ impl SdmmcInner { // Enforce AHB and SDMMC_CK clock relation. See RM0433 Rev 7 // Section 55.5.8 let sdmmc_bus_bandwidth = new_clock.0 * (width as u32); - self::assert!(hclk.0 > 3 * sdmmc_bus_bandwidth / 32); + assert!(hclk.0 > 3 * sdmmc_bus_bandwidth / 32); *clock = new_clock; // NOTE(unsafe) We have exclusive access to the regblock diff --git a/embassy/src/executor/mod.rs b/embassy/src/executor/mod.rs index 8a3a8991a..598d4e558 100644 --- a/embassy/src/executor/mod.rs +++ b/embassy/src/executor/mod.rs @@ -9,7 +9,6 @@ mod timer_queue; mod util; mod waker; -use crate::fmt::panic; use crate::interrupt::{Interrupt, InterruptExt}; use crate::time::Alarm; diff --git a/embassy/src/executor/waker.rs b/embassy/src/executor/waker.rs index 050f6a1cf..ea5b501f1 100644 --- a/embassy/src/executor/waker.rs +++ b/embassy/src/executor/waker.rs @@ -24,7 +24,9 @@ pub(crate) unsafe fn from_task(p: NonNull) -> Waker { pub unsafe fn task_from_waker(waker: &Waker) -> NonNull { let hack: &WakerHack = mem::transmute(waker); - assert_eq!(hack.vtable, &VTABLE); + if hack.vtable != &VTABLE { + panic!("Found waker not created by the embassy executor. Consider enabling the `executor-agnostic` feature on the `embassy` crate.") + } NonNull::new_unchecked(hack.data as *mut TaskHeader) } diff --git a/embassy/src/fmt.rs b/embassy/src/fmt.rs index 160642ccd..6c5063f7c 100644 --- a/embassy/src/fmt.rs +++ b/embassy/src/fmt.rs @@ -1,69 +1,170 @@ #![macro_use] -#![allow(clippy::module_inception)] -#![allow(unused)] +#![allow(unused_macros)] #[cfg(all(feature = "defmt", feature = "log"))] compile_error!("You may not enable both `defmt` and `log` features."); -pub use fmt::*; +macro_rules! assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert!($($x)*); + } + }; +} + +macro_rules! assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_eq!($($x)*); + } + }; +} + +macro_rules! assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::assert_ne!($($x)*); + } + }; +} + +macro_rules! debug_assert { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert!($($x)*); + } + }; +} + +macro_rules! debug_assert_eq { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_eq!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_eq!($($x)*); + } + }; +} + +macro_rules! debug_assert_ne { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::debug_assert_ne!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug_assert_ne!($($x)*); + } + }; +} + +macro_rules! todo { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::todo!($($x)*); + #[cfg(feature = "defmt")] + defmt::todo!($($x)*); + } + }; +} + +macro_rules! unreachable { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::unreachable!($($x)*); + #[cfg(feature = "defmt")] + defmt::unreachable!($($x)*); + } + }; +} + +macro_rules! panic { + ($($x:tt)*) => { + { + #[cfg(not(feature = "defmt"))] + core::panic!($($x)*); + #[cfg(feature = "defmt")] + defmt::panic!($($x)*); + } + }; +} + +macro_rules! trace { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::trace!($($x)*); + #[cfg(feature = "defmt")] + defmt::trace!($($x)*); + } + }; +} + +macro_rules! debug { + ($($x:tt)*) => { + { + #[cfg(fevature = "log")] + log::debug!($($x)*); + #[cfg(feature = "defmt")] + defmt::debug!($($x)*); + } + }; +} + +macro_rules! info { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::info!($($x)*); + #[cfg(feature = "defmt")] + defmt::info!($($x)*); + } + }; +} + +macro_rules! warn { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::warn!($($x)*); + #[cfg(feature = "defmt")] + defmt::warn!($($x)*); + } + }; +} + +macro_rules! error { + ($($x:tt)*) => { + { + #[cfg(feature = "log")] + log::error!($($x)*); + #[cfg(feature = "defmt")] + defmt::error!($($x)*); + } + }; +} #[cfg(feature = "defmt")] -mod fmt { - pub use defmt::{ - assert, assert_eq, assert_ne, debug, debug_assert, debug_assert_eq, debug_assert_ne, error, - info, panic, todo, trace, unreachable, unwrap, warn, +macro_rules! unwrap { + ($($x:tt)*) => { + defmt::unwrap!($($x)*) }; } -#[cfg(feature = "log")] -mod fmt { - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - pub use log::{debug, error, info, trace, warn}; -} - -#[cfg(not(any(feature = "defmt", feature = "log")))] -mod fmt { - #![macro_use] - - pub use core::{ - assert, assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, panic, todo, - unreachable, - }; - - macro_rules! trace { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! debug { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! info { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! warn { - ($($msg:expr),+ $(,)?) => { - () - }; - } - - macro_rules! error { - ($($msg:expr),+ $(,)?) => { - () - }; - } -} - #[cfg(not(feature = "defmt"))] macro_rules! unwrap { ($arg:expr) => { diff --git a/embassy/src/time/mod.rs b/embassy/src/time/mod.rs index d7284b7a2..21b93d384 100644 --- a/embassy/src/time/mod.rs +++ b/embassy/src/time/mod.rs @@ -10,8 +10,6 @@ pub use duration::Duration; pub use instant::Instant; pub use traits::*; -use crate::fmt::*; - // TODO allow customizing, probably via Cargo features `tick-hz-32768` or something. pub const TICKS_PER_SECOND: u64 = 32768; diff --git a/embassy/src/util/drop_bomb.rs b/embassy/src/util/drop_bomb.rs index 388209a23..efb36a97d 100644 --- a/embassy/src/util/drop_bomb.rs +++ b/embassy/src/util/drop_bomb.rs @@ -1,4 +1,3 @@ -use crate::fmt::panic; use core::mem; /// An explosive ordinance that panics if it is improperly disposed of. diff --git a/embassy/src/util/mutex.rs b/embassy/src/util/mutex.rs index 86ab070a3..e4b7764ce 100644 --- a/embassy/src/util/mutex.rs +++ b/embassy/src/util/mutex.rs @@ -1,8 +1,6 @@ use core::cell::UnsafeCell; use critical_section::CriticalSection; -use crate::fmt::assert; - /// A "mutex" based on critical sections /// /// # Safety diff --git a/embassy/src/util/portal.rs b/embassy/src/util/portal.rs index f4f2824aa..8ea481093 100644 --- a/embassy/src/util/portal.rs +++ b/embassy/src/util/portal.rs @@ -1,4 +1,3 @@ -use crate::fmt::panic; use core::cell::UnsafeCell; use core::mem; use core::mem::MaybeUninit; diff --git a/embassy/src/util/signal.rs b/embassy/src/util/signal.rs index 2eefe658b..af261c457 100644 --- a/embassy/src/util/signal.rs +++ b/embassy/src/util/signal.rs @@ -9,7 +9,6 @@ use executor::raw::TaskHeader; use ptr::NonNull; use crate::executor; -use crate::fmt::panic; use crate::interrupt::{Interrupt, InterruptExt}; /// Synchronization primitive. Allows creating awaitable signals that may be passed between tasks.