WIP

.clang-format

@@ -4,7 +4,7 @@ IndentWidth: 4
 TabWidth: 4
 BreakBeforeBraces: Custom
 AllowShortFunctionsOnASingleLine: Inline
-AllowShortBlocksOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: true
 AllowShortLambdasOnASingleLine: true
 AllowAllArgumentsOnNextLine: true
 IndentCaseLabels: true
@@ -13,12 +13,15 @@ NamespaceIndentation: None
 FixNamespaceComments: false
 PackConstructorInitializers: Never
 AlignAfterOpenBracket: AlwaysBreak
-BreakConstructorInitializersBeforeComma: true
 InsertBraces: true
+SpaceBeforeParens: Custom
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterFunctionDefinitionName: false
 BraceWrapping:
   AfterClass: true # false
   AfterControlStatement: false
-  AfterEnum: true # false
+  AfterEnum: false # false
   AfterFunction: true # false
   AfterNamespace: false
   AfterObjCDeclaration: true # false

inc/f4ll/console_handler.h

@@ -35,16 +35,6 @@ public:
 
     iringbuffer &get_rx_buffer() { return m_rx_buffer; }
 
-    // ioutput_stream interface implementations
-    ioutput_stream &operator<<(ioutput_stream::format fmt) override;
-    ioutput_stream &operator<<(char const *str) override;
-    ioutput_stream &operator<<(char chr) override;
-    ioutput_stream &operator<<(uint8_t byte) override;
-    ioutput_stream &operator<<(uint16_t ui16) override;
-    ioutput_stream &operator<<(int16_t i16) override;
-    ioutput_stream &operator<<(uint32_t ui32) override;
-    ioutput_stream &operator<<(int32_t i32) override;
-
 private:
     console_handler(
         USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx, uint8_t *rx_buffer, size_type x_buffer_size,
@@ -64,6 +54,16 @@ private:
     void tx_dma_half_transfer(void) override;
     void tx_dma_error(dma_helper::dma_error_type reason) override;
 
+    // ioutput_stream interface implementations
+    ioutput_stream &operator<<(ioutput_stream::format fmt) override;
+    ioutput_stream &operator<<(char const *str) override;
+    ioutput_stream &operator<<(char chr) override;
+    ioutput_stream &operator<<(uint8_t byte) override;
+    ioutput_stream &operator<<(uint16_t ui16) override;
+    ioutput_stream &operator<<(int16_t i16) override;
+    ioutput_stream &operator<<(uint32_t ui32) override;
+    ioutput_stream &operator<<(int32_t i32) override;
+
     // iotput_stream-related member variables
     ioutput_stream::format m_fmt = ioutput_stream::format::dec;
 

src/console_handler.cpp

@@ -10,17 +10,16 @@
 #include <f4ll/str_util.h>
 
 #include <cstring>
-#include <type_traits>
 
 namespace f4ll {
 
 console_handler::console_handler(
     USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t stream_rx, uint32_t stream_tx, uint8_t *rx_buffer, size_type rx_buffer_size,
     uint8_t *tx_buffer, size_type tx_buffer_size, iconsole_input *rx_callback)
-    : usart_core(usart, dma, stream_rx, stream_tx)
+    : usart_core(usart, dma, stream_rx, stream_tx),
-    , m_tx_buffer(tx_buffer, tx_buffer_size)
+      m_tx_buffer(tx_buffer, tx_buffer_size),
-    , m_rx_buffer(rx_buffer, rx_buffer_size)
+      m_rx_buffer(rx_buffer, rx_buffer_size),
-    , m_rx_callback(rx_callback)
+      m_rx_callback(rx_callback)
 {
     LL_USART_EnableIT_IDLE(usart);
     LL_USART_EnableIT_ERROR(usart);
@@ -38,7 +37,7 @@ void console_handler::receiver_idle(void)
 {
     uint16_t rcvd_bytes = m_bytes_requested - m_reqd_bytes_registered - LL_DMA_GetDataLength(m_rx_dma.get_dma(), m_rx_dma.get_stream());
     if (rcvd_bytes) {
-        m_reqd_bytes_registered += rcvd_bytes;
+    	m_reqd_bytes_registered += rcvd_bytes;
         m_rx_buffer.produced(rcvd_bytes);
         m_rx_buffer.commit();
         if (m_rx_callback) {
@@ -159,30 +158,29 @@ ioutput_stream &console_handler::operator<<(uint8_t byte)
 
 ioutput_stream &console_handler::operator<<(uint16_t ui16)
 {
-    print_unsigned(ui16);
     return *this;
 }
 
 ioutput_stream &console_handler::operator<<(int16_t i16)
 {
-    print_signed(i16);
     return *this;
 }
 
 ioutput_stream &console_handler::operator<<(uint32_t ui32)
 {
-    print_unsigned(ui32);
     return *this;
 }
 
 ioutput_stream &console_handler::operator<<(int32_t i32)
 {
-    print_signed(i32);
     return *this;
 }
 
 template <typename T> void console_handler::print_unsigned(T input)
 {
+    static constexpr uint32_t const divisors[4] = {100, 10000, 10000000, 1000000000};
+    T divisor = static_cast<T>(divisors[sizeof(T) - 1]);
+
     if (m_fmt != ioutput_stream::format::dec) {
         append("0x");
     }
@@ -196,50 +194,26 @@ template <typename T> void console_handler::print_unsigned(T input)
     uint8_t cres;
 
     if (m_fmt == ioutput_stream::format::dec) {
-        static constexpr uint32_t const divisors[4] = {100, 10000, 10000000, 1000000000};
-        T divisor = static_cast<T>(divisors[sizeof(T) - 1]);
-        bool found = false;
-
         while (divisor) {
             res = input / divisor;
-            if (res || found) {
+            if (res) {
                 cres = static_cast<uint8_t>(res + '0');
                 m_tx_buffer.put(&cres, 1);
                 input -= res * divisor;
-                found = true;
             }
             divisor /= 10;
         }
-    } else {
-        uint8_t nibbles = sizeof(T) * 2;
-        bool found = false;
-        do {
-            uint8_t shift = (nibbles - 1) * 4;
-            T mask = 0xf << shift;
-            uint8_t bin = (input & mask) >> shift;
-            uint8_t chr = bin <= 9 ? bin + '0' : bin - 10 + 'A';
-            if (!found && !bin && m_fmt == ioutput_stream::format::hex_trimmed) {
-                continue;
-            }
-            found = true;
-            m_tx_buffer.put(&chr, 1);
-        } while (--nibbles);
     }
-    flush();
 }
 
 template <typename T> void console_handler::print_signed(T input)
 {
-    using unsigned_t = typename std::make_unsigned<T>::type;
+    if (m_fmt == ioutput_stream::format::dec) {
-    unsigned_t uinput;
-
-    if (m_fmt == ioutput_stream::format::dec && input < 0) {
         append("-");
-        uinput = static_cast<unsigned_t>(-input);
+        print_unsigned(-input);
     } else {
-        uinput = static_cast<unsigned_t>(input);
+        print_unsigned(input);
     }
-    print_unsigned(uinput);
 }
 
 } /* namespace f4ll */

src/dma_helper.cpp

@@ -10,12 +10,12 @@ q * ll_dmahelper.cpp
 namespace f4ll {
 
 dma_helper::dma_helper(DMA_TypeDef *dma, uint32_t stream)
-    : m_dma(dma)
+    : m_dma(dma),
-    , m_stream(stream)
+      m_stream(stream),
-    , m_is_reg(
+      m_is_reg(
           (dma == DMA1) ? ((m_stream < LL_DMA_STREAM_4) ? &DMA1->LISR : &DMA1->HISR)
-                        : ((m_stream < LL_DMA_STREAM_4) ? &DMA2->LISR : &DMA2->HISR))
+                        : ((m_stream < LL_DMA_STREAM_4) ? &DMA2->LISR : &DMA2->HISR)),
-    , m_ifc_reg(
+      m_ifc_reg(
           (dma == DMA1) ? ((m_stream < LL_DMA_STREAM_4) ? &DMA1->LIFCR : &DMA1->HIFCR)
                         : ((m_stream < LL_DMA_STREAM_4) ? &DMA2->LIFCR : &DMA2->HIFCR))
 {

src/ringbuffer.cpp

@@ -5,8 +5,8 @@
 namespace f4ll {
 
 ringbuffer_ext::ringbuffer_ext(uint8_t *bptr, size_type bsize)
-    : m_buffer(bptr)
+    : m_buffer(bptr),
-    , m_bsize(bsize)
+      m_bsize(bsize)
 {
 }
 

src/usart_core.cpp

@@ -10,9 +10,9 @@
 namespace f4ll {
 
 usart_core::usart_core(USART_TypeDef *usart, DMA_TypeDef *dma, uint32_t streamRx, uint32_t streamTx)
-    : m_usart(usart)
+    : m_usart(usart),
-    , m_rx_dma(dma, streamRx)
+      m_rx_dma(dma, streamRx),
-    , m_tx_dma(dma, streamTx)
+      m_tx_dma(dma, streamTx)
 {
     uint32_t status = usart->SR;
     volatile uint32_t tmpreg = usart->DR; // clearing some of the error/status bits in the USART