qs.hpp

Go to the documentation of this file.

 
#ifndef QS_HPP
#define QS_HPP
 
#ifndef Q_SPY
    #error "Q_SPY must be defined to include qs.hpp"
#endif
 
//****************************************************************************
namespace QP {
 
 
enum QSpyRecords : std::int8_t {
    // [0] QS session (not maskable)
    QS_EMPTY,             
 
    // [1] SM records
    QS_QEP_STATE_ENTRY,   
    QS_QEP_STATE_EXIT,    
    QS_QEP_STATE_INIT,    
    QS_QEP_INIT_TRAN,     
    QS_QEP_INTERN_TRAN,   
    QS_QEP_TRAN,          
    QS_QEP_IGNORED,       
    QS_QEP_DISPATCH,      
    QS_QEP_UNHANDLED,     
 
    // [10] Active Object (AO) records
    QS_QF_ACTIVE_DEFER,   
    QS_QF_ACTIVE_RECALL,  
    QS_QF_ACTIVE_SUBSCRIBE,  
    QS_QF_ACTIVE_UNSUBSCRIBE,
    QS_QF_ACTIVE_POST,      
    QS_QF_ACTIVE_POST_LIFO, 
    QS_QF_ACTIVE_GET,     
    QS_QF_ACTIVE_GET_LAST,
    QS_QF_ACTIVE_RECALL_ATTEMPT, 
 
    // [19] Event Queue (EQ) records
    QS_QF_EQUEUE_POST,      
    QS_QF_EQUEUE_POST_LIFO, 
    QS_QF_EQUEUE_GET,     
    QS_QF_EQUEUE_GET_LAST,
 
    // [23] Framework (QF) records */
    QS_QF_NEW_ATTEMPT,    
 
    // [24] Memory Pool (MP) records
    QS_QF_MPOOL_GET,      
    QS_QF_MPOOL_PUT,      
 
    // [26] Additional Framework (QF) records
    QS_QF_PUBLISH,        
    QS_QF_NEW_REF,        
    QS_QF_NEW,            
    QS_QF_GC_ATTEMPT,     
    QS_QF_GC,             
    QS_QF_TICK,           
 
    // [32] Time Event (TE) records
    QS_QF_TIMEEVT_ARM,    
    QS_QF_TIMEEVT_AUTO_DISARM, 
    QS_QF_TIMEEVT_DISARM_ATTEMPT,
    QS_QF_TIMEEVT_DISARM, 
    QS_QF_TIMEEVT_REARM,  
    QS_QF_TIMEEVT_POST,   
 
    // [38] Additional Framework (QF) records
    QS_QF_DELETE_REF,     
    QS_QF_CRIT_ENTRY,     
    QS_QF_CRIT_EXIT,      
    QS_QF_ISR_ENTRY,      
    QS_QF_ISR_EXIT,       
    QS_QF_INT_DISABLE,    
    QS_QF_INT_ENABLE,     
 
    // [45] Additional Active Object (AO) records
    QS_QF_ACTIVE_POST_ATTEMPT, 
 
    // [46] Additional Event Queue (EQ) records
    QS_QF_EQUEUE_POST_ATTEMPT, 
 
    // [47] Additional Memory Pool (MP) records
    QS_QF_MPOOL_GET_ATTEMPT,   
 
    // [48] Scheduler (SC) records
    QS_MUTEX_LOCK,        
    QS_MUTEX_UNLOCK,      
    QS_SCHED_LOCK,        
    QS_SCHED_UNLOCK,      
    QS_SCHED_NEXT,        
    QS_SCHED_IDLE,        
    QS_SCHED_RESUME,      
 
    // [55] Additional QEP records
    QS_QEP_TRAN_HIST,     
    QS_QEP_TRAN_EP,       
    QS_QEP_TRAN_XP,       
 
    // [58] Miscellaneous QS records (not maskable)
    QS_TEST_PAUSED,       
    QS_TEST_PROBE_GET,    
    QS_SIG_DICT,          
    QS_OBJ_DICT,          
    QS_FUN_DICT,          
    QS_USR_DICT,          
    QS_TARGET_INFO,       
    QS_TARGET_DONE,       
    QS_RX_STATUS,         
    QS_QUERY_DATA,        
    QS_PEEK_DATA,         
    QS_ASSERT_FAIL,       
    QS_QF_RUN,            
 
    // [71] Reserved QS records
    QS_RESERVED_71,
    QS_RESERVED_72,
    QS_RESERVED_73,
    QS_RESERVED_74,
    QS_RESERVED_75,
    QS_RESERVED_76,
    QS_RESERVED_77,
    QS_RESERVED_78,
    QS_RESERVED_79,
    QS_RESERVED_80,
    QS_RESERVED_81,
    QS_RESERVED_82,
    QS_RESERVED_83,
    QS_RESERVED_84,
    QS_RESERVED_85,
    QS_RESERVED_86,
    QS_RESERVED_87,
    QS_RESERVED_88,
    QS_RESERVED_89,
    QS_RESERVED_90,
    QS_RESERVED_91,
    QS_RESERVED_92,
    QS_RESERVED_93,
    QS_RESERVED_94,
    QS_RESERVED_95,
    QS_RESERVED_96,
    QS_RESERVED_97,
    QS_RESERVED_98,
    QS_RESERVED_99,
 
    // [100] Application-specific (User) QS records
    QS_USER               
};
 
enum QSpyRecordGroups : std::int16_t {
    QS_ALL_RECORDS = static_cast<std::uint8_t>(0xF0U), 
    QS_SM_RECORDS,  
    QS_AO_RECORDS,  
    QS_EQ_RECORDS,  
    QS_MP_RECORDS,  
    QS_TE_RECORDS,  
    QS_QF_RECORDS,  
    QS_SC_RECORDS,  
    QS_U0_RECORDS,  
    QS_U1_RECORDS,  
    QS_U2_RECORDS,  
    QS_U3_RECORDS,  
    QS_U4_RECORDS,  
    QS_UA_RECORDS   
};
 
enum QSpyUserOffsets : std::int16_t {
    QS_USER0 = QS_USER,      
    QS_USER1 = QS_USER0 + 5, 
    QS_USER2 = QS_USER1 + 5, 
    QS_USER3 = QS_USER2 + 5, 
    QS_USER4 = QS_USER3 + 5, 
};
 
enum QSpyIdOffsets : std::int16_t {
    QS_AO_ID = 0,  
    QS_EP_ID = 64, 
    QS_EQ_ID = 80, 
    QS_AP_ID = 96, 
};
 
enum QSpyIdGroups : std::int16_t {
    QS_ALL_IDS = 0xF0,            
    QS_AO_IDS  = 0x80 + QS_AO_ID, 
    QS_EP_IDS  = 0x80 + QS_EP_ID, 
    QS_EQ_IDS  = 0x80 + QS_EQ_ID, 
    QS_AP_IDS  = 0x80 + QS_AP_ID, 
};
 
struct QSpyId {
    std::uint8_t m_prio;
    std::uint_fast8_t getPrio(void) const noexcept {
        return static_cast<std::uint_fast8_t>(m_prio);
    }
};
 
} // namespace QP ************************************************************
 
#ifndef QS_TIME_SIZE
 
 
    #define QS_TIME_SIZE 4U
#endif
 
#if (QS_TIME_SIZE == 1U)
    #define QS_TIME_PRE_() (QP::QS::u8_raw_(QP::QS::onGetTime()))
#elif (QS_TIME_SIZE == 2U)
    #define QS_TIME_PRE_() (QP::QS::u16_raw_(QP::QS::onGetTime()))
#elif (QS_TIME_SIZE == 4U)
    #define QS_TIME_PRE_() (QP::QS::u32_raw_(QP::QS::onGetTime()))
#else
    #error "QS_TIME_SIZE defined incorrectly, expected 1U, 2U, or 4U"
#endif
 
 
//****************************************************************************
namespace QP {
 
#if (QS_TIME_SIZE == 1U)
    using QSTimeCtr = std::uint8_t;
#elif (QS_TIME_SIZE == 2U)
    using QSTimeCtr = std::uint16_t;
#elif (QS_TIME_SIZE == 4U)
    // range of QS time stamps
    //
    using QSTimeCtr = std::uint32_t;
#endif
 
using QSCtr = std::uint_fast16_t;
 
constexpr std::uint16_t QS_EOD  = 0xFFFFU;
 
class QS {
public:
    static void initBuf(std::uint8_t * const sto,
                        std::uint_fast16_t const stoSize) noexcept;
 
    //  or a group of records.
    static void glbFilter_(std::int_fast16_t const filter) noexcept;
 
    //  or a group of object-ids.
    static void locFilter_(std::int_fast16_t const filter) noexcept;
 
    static void beginRec_(std::uint_fast8_t const rec) noexcept;
 
    static void endRec_(void) noexcept;
 
    // raw (unformatted) output of data elements .............................
 
    static void u8_raw_(std::uint8_t const d) noexcept;
 
    static void u8u8_raw_(std::uint8_t const d1,
                          std::uint8_t const d2) noexcept;
 
    static void u16_raw_(std::uint16_t d) noexcept;
 
    static void u32_raw_(std::uint32_t d) noexcept;
 
    static void obj_raw_(void const * const obj) noexcept;
 
    static void str_raw_(char_t const *s) noexcept;
 
 
    // formatted data elements output ........................................
 
    static void u8_fmt_(std::uint8_t const format,
                        std::uint8_t const d) noexcept;
 
    static void u16_fmt_(std::uint8_t format, std::uint16_t d) noexcept;
 
    static void u32_fmt_(std::uint8_t format, std::uint32_t d) noexcept;
 
    static void f32_fmt_(std::uint8_t format, float32_t const d) noexcept;
 
    static void f64_fmt_(std::uint8_t format, float64_t const d) noexcept;
 
    static void str_fmt_(char_t const *s) noexcept;
 
    static void mem_fmt_(std::uint8_t const *blk, std::uint8_t size) noexcept;
 
    static void u64_raw_(std::uint64_t d) noexcept;
 
    static void u64_fmt_(std::uint8_t format, std::uint64_t d) noexcept;
 
    static void sig_dict_pre_(enum_t const sig, void const * const obj,
                              char_t const *name) noexcept;
 
    static void obj_dict_pre_(void const * const obj,
                              char_t const *name) noexcept;
 
    static void fun_dict_pre_(void (* const fun)(void),
                              char_t const *name) noexcept;
 
    static void usr_dict_pre_(enum_t const rec,
                              char_t const * const name) noexcept;
 
    static void rxInitBuf(std::uint8_t * const sto,
                          std::uint16_t const stoSize) noexcept;
 
    static void rxParse(void);
 
    static std::uint16_t rxGetNfree(void) noexcept;
 
    static bool rxPut(std::uint8_t const b) noexcept;
 
    static void setCurrObj(std::uint8_t obj_kind, void *obj_ptr) noexcept;
 
    static void queryCurrObj(std::uint8_t obj_kind) noexcept;
 
    // QS buffer access ......................................................
    static std::uint16_t getByte(void) noexcept;
 
    static std::uint8_t const *getBlock(
                               std::uint16_t * const pNbytes) noexcept;
 
    // platform-dependent callback functions to be implemented by clients ....
 
    static bool onStartup(void const *arg);
 
    static void onCleanup(void);
 
    static void onFlush(void);
 
    static QSTimeCtr onGetTime(void);
 
    static void onReset(void);
 
    static void onCommand(std::uint8_t cmdId,
                          std::uint32_t param1,
                          std::uint32_t param2,
                          std::uint32_t param3);
 
    static void rxHandleGoodFrame_(std::uint8_t const state);
 
    static void assertion_pre_(char_t const * const module, int_t const loc,
                               std::uint32_t delay);
 
    static void crit_entry_pre_(void);
 
    static void crit_exit_pre_(void);
 
    static void isr_entry_pre_(std::uint8_t const isrnest,
                               std::uint8_t const prio);
 
    static void isr_exit_pre_(std::uint8_t const isrnest,
                              std::uint8_t const prio);
 
#ifdef Q_UTEST
    static void onTestSetup(void);
 
    static void onTestTeardown(void);
 
    static void onTestEvt(QEvt *e);
 
    // callback to examine an event that is about to be posted
    static void onTestPost(void const *sender, QActive *recipient,
                           QEvt const *e, bool status);
 
    static void onTestLoop(void);
 
    static void processTestEvts_(void);
 
    static void tickX_(std::uint_fast8_t const tickRate,
                       void const * const sender) noexcept;
 
    static std::uint32_t getTestProbe_(void (* const api)(void)) noexcept;
 
#endif // Q_UTEST
 
    enum QSType : std::uint8_t {
        I8_T,         
        U8_T,         
        I16_T,        
        U16_T,        
        I32_T,        
        U32_T,        
        F32_T,        
        F64_T,        
        STR_T,        
        MEM_T,        
        SIG_T,        
        OBJ_T,        
        FUN_T,        
        I64_T,        
        U64_T,        
        HEX_FMT       
    };
 
    enum QSpyObjKind : std::uint8_t {
        SM_OBJ,       
        AO_OBJ,       
        MP_OBJ,       
        EQ_OBJ,       
        TE_OBJ,       
        AP_OBJ,       
        MAX_OBJ
    };
 
    enum OSpyObjCombnation : std::uint8_t {
        SM_AO_OBJ = MAX_OBJ 
    };
 
    template<typename T_OUT, typename T_IN>
    static T_OUT force_cast(T_IN in) {
        union TCast {
            T_IN  in;
            T_OUT out;
        } u = { in };
        return u.out;
    }
 
    // private QS attributes .................................................
    std::uint8_t glbFilter[16];  
    std::uint8_t locFilter[16];  
    void const *locFilter_AP; 
    std::uint8_t *buf;    
    QSCtr    end;         
    QSCtr    head;        
    QSCtr    tail;        
    QSCtr    used;        
    std::uint8_t  seq;    
    std::uint8_t  chksum; 
    std::uint8_t  full;   
 
    std::uint_fast8_t critNest; 
 
    static QS priv_;
 
    static struct QSrxPriv {
        void *currObj[MAX_OBJ]; 
        std::uint8_t *buf;      
        QSCtr end;        
        QSCtr head;       
        QSCtr tail;       
#ifdef Q_UTEST
        QP::QPSet readySet; 
        bool inTestLoop;    
#endif
    } rxPriv_;
};
 
//****************************************************************************
// QS receive channel
 
enum QSpyRxRecords : std::uint8_t {
    QS_RX_INFO,           
    QS_RX_COMMAND,        
    QS_RX_RESET,          
    QS_RX_TICK,           
    QS_RX_PEEK,           
    QS_RX_POKE,           
    QS_RX_FILL,           
    QS_RX_TEST_SETUP,     
    QS_RX_TEST_TEARDOWN,  
    QS_RX_TEST_PROBE,     
    QS_RX_GLB_FILTER,     
    QS_RX_LOC_FILTER,     
    QS_RX_AO_FILTER,      
    QS_RX_CURR_OBJ,       
    QS_RX_TEST_CONTINUE,  
    QS_RX_QUERY_CURR,     
    QS_RX_EVENT           
};
 
inline bool QS::rxPut(std::uint8_t const b) noexcept {
    QSCtr head = rxPriv_.head + 1U;
    if (head == rxPriv_.end) {
        head = 0U;
    }
    if (head != rxPriv_.tail) { // buffer NOT full?
        rxPriv_.buf[rxPriv_.head] = b;
        rxPriv_.head = head;
        return true;  // byte placed in the buffer
    }
    else {
        return false; // byte NOT placed in the buffer
    }
}
 
 
//****************************************************************************
#ifdef Q_UTEST
 
class QActiveDummy : public QActive {
public:
    QActiveDummy(void); // ctor
 
    void start(std::uint_fast8_t const prio,
               QEvt const * * const qSto, std::uint_fast16_t const qLen,
               void * const stkSto, std::uint_fast16_t const stkSize,
               void const * const par) override;
 
    void start(std::uint_fast8_t const prio,
               QEvt const * * const qSto, std::uint_fast16_t const qLen,
               void * const stkSto, std::uint_fast16_t const stkSize) override
    {
        this->start(prio, qSto, qLen, stkSto, stkSize, nullptr);
    }
 
    void init(void const * const e,
              std::uint_fast8_t const qs_id) noexcept override;
    void init(std::uint_fast8_t const qs_id) noexcept override {
        this->init(qs_id);
    }
    void dispatch(QEvt const * const e,
                  std::uint_fast8_t const qs_id) noexcept override;
    bool post_(QEvt const * const e,
               std::uint_fast16_t const margin,
               void const * const sender) noexcept override;
    void postLIFO(QEvt const * const e) noexcept override;
};
 
constexpr std::uint8_t QUTEST_ON_POST {124U};
 
// interrupt nesting up-down counter
extern std::uint8_t volatile QF_intNest;
 
#endif // Q_UTEST
 
} // namespace QP
 
//****************************************************************************
// Macros for adding QS instrumentation to the client code
 
#define QS_INIT(arg_)           (QP::QS::onStartup(arg_))
 
#define QS_EXIT()               (QP::QS::onCleanup())
 
#define QS_GLB_FILTER(rec_) \
    (QP::QS::glbFilter_(static_cast<std::int_fast16_t>(rec_)))
 
#define QS_LOC_FILTER(qs_id_)  \
    (QP::QS::locFilter_(static_cast<std::int_fast16_t>(qs_id_)))
 
 
//****************************************************************************
// Macros to generate application-specific (user) QS records
 
#define QS_BEGIN_ID(rec_, qs_id_)                                \
    if (QS_GLB_CHECK_(rec_) && QS_LOC_CHECK_(qs_id_)) {          \
        QS_CRIT_STAT_                                            \
        QS_CRIT_E_();                                            \
        QP::QS::beginRec_(static_cast<std::uint_fast8_t>(rec_)); \
        QS_TIME_PRE_();
 
#define QS_END()           \
        QP::QS::endRec_(); \
        QS_CRIT_X_();      \
    }
 
#define QS_BEGIN_NOCRIT(rec_, qs_id_)                            \
    if (QS_GLB_CHECK_(rec_) && QS_LOC_CHECK_(qs_id_)) {          \
        QP::QS::beginRec_(rec_);                                 \
        QS_TIME_PRE_();
 
#define QS_END_NOCRIT()    \
        QP::QS::endRec_(); \
    }
 
#ifndef QS_REC_DONE
    #define QS_REC_DONE() (static_cast<void>(0))
#endif // QS_REC_DONE
 
#define QS_GLB_CHECK_(rec_)                                              \
    ((QP::QS::priv_.glbFilter[static_cast<std::uint_fast8_t>(rec_) >> 3] \
      & static_cast<std::uint8_t>(1U                                     \
             << (static_cast<std::uint_fast8_t>(rec_) & 7U))) != 0U)
 
#define QS_LOC_CHECK_(qs_id_)                                              \
    ((QP::QS::priv_.locFilter[static_cast<std::uint_fast8_t>(qs_id_) >> 3] \
      & static_cast<std::uint8_t>(1U                                       \
             << (static_cast<std::uint_fast8_t>(qs_id_) & 7U))) != 0U)
 
 
//****************************************************************************
// Facilities for QS ciritical section
 
// QS-specific critical section
#ifdef QS_CRIT_ENTRY // separate QS critical section defined?
 
#ifndef QS_CRIT_STAT_TYPE
    #define QS_CRIT_STAT_
    #define QS_CRIT_E_()    QS_CRIT_ENTRY(dummy)
    #define QS_CRIT_X_()     QS_CRIT_EXIT(dummy); QS_REC_DONE()
#else
    #define QS_CRIT_STAT_       QS_CRIT_STAT_TYPE critStat_;
    #define QS_CRIT_E_()    QS_CRIT_ENTRY(critStat_)
    #define QS_CRIT_X_()     QS_CRIT_EXIT(critStat_); QS_REC_DONE()
#endif // QS_CRIT_STAT_TYPE
 
#else // separate QS critical section not defined--use the QF definition
#ifndef QF_CRIT_STAT_TYPE
    #define QS_CRIT_STAT_
 
    #define QS_CRIT_E_()    QF_CRIT_ENTRY(dummy)
 
    #define QS_CRIT_X_()     QF_CRIT_EXIT(dummy); QS_REC_DONE()
 
#elif (!defined QS_CRIT_STAT_)
    #define QS_CRIT_STAT_       QF_CRIT_STAT_TYPE critStat_;
    #define QS_CRIT_E_()    QF_CRIT_ENTRY(critStat_)
    #define QS_CRIT_X_()     QF_CRIT_EXIT(critStat_); QS_REC_DONE()
#endif // simple unconditional interrupt disabling used
 
#endif // separate QS critical section not defined
 
 
//****************************************************************************
// Macros for use in the client code
 
#define QS_I8(width_, data_)                                \
    (QP::QS::u8_fmt_(static_cast<std::uint8_t>(             \
        (static_cast<std::uint8_t>(width_) << 4))           \
        | static_cast<std::uint8_t>(QP::QS::I8_T)), (data_)))
 
#define QS_U8(width_, data_)                                \
    (QP::QS::u8_fmt_(static_cast<std::uint8_t>(             \
        (static_cast<std::uint8_t>((width_) << 4))          \
        | static_cast<std::uint8_t>(QP::QS::U8_T)), (data_)))
 
#define QS_I16(width_, data_)                                \
    (QP::QS::u16_fmt_(static_cast<std::uint8_t>(             \
        (static_cast<std::uint8_t>((width_) << 4))           \
        | static_cast<std::uint8_t>(QP::QS::I16_T)), (data_)))
 
#define QS_U16(width_, data_)                                     \
    (QP::QS::u16_fmt_(static_cast<std::uint8_t>((((width_) << 4)) \
        | static_cast<std::uint8_t>(QP::QS::U16_T)), (data_)))
 
#define QS_I32(width_, data_)                                      \
    (QP::QS::u32_fmt_(                                             \
        static_cast<std::uint8_t>((static_cast<std::uint8_t>((width_) << 4)) \
        | static_cast<std::uint8_t>(QP::QS::I32_T)), (data_)))
 
#define QS_U32(width_, data_)                                \
    (QP::QS::u32_fmt_(static_cast<std::uint8_t>(             \
        (static_cast<std::uint8_t>((width_) << 4))           \
        | static_cast<std::uint8_t>(QP::QS::U32_T)), (data_)))
 
#define QS_I64(width_, data_)                                \
    (QP::QS::u64_fmt_(static_cast<std::uint8_t>(             \
        (static_cast<std::uint8_t>((width_) << 4))           \
        | static_cast<std::uint8_t>(QP::QS::I64_T)), (data_)))
 
#define QS_U64(width_, data_)                                \
    (QP::QS::u64_fmt_(static_cast<std::uint8_t>(             \
        (static_cast<std::uint8_t>((width_) << 4))           \
            | static_cast<std::uint8_t>(QP::QS::U64_T)), (data_)))
 
#define QS_F32(width_, data_)                                \
    (QP::QS::f32_fmt_(static_cast<std::uint8_t>(             \
        (static_cast<std::uint8_t>((width_) << 4))           \
        | static_cast<std::uint8_t>(QP::QS::F32_T)), (data_)))
 
#define QS_F64(width_, data_)                                \
    (QP::QS::f64_fmt_(static_cast<std::uint8_t>(             \
        (static_cast<std::uint8_t>((width_) << 4))           \
        | static_cast<std::uint8_t>(QP::QS::F64_T)), (data_)))
 
#define QS_STR(str_)        (QP::QS::str_fmt_(str_))
 
#define QS_MEM(mem_, size_) (QP::QS::mem_fmt_((mem_), (size_)))
 
 
#if (QS_OBJ_PTR_SIZE == 1U)
    #define QS_OBJ(obj_) (QP::QS::u8_fmt_(QP::QS::OBJ_T, \
        reinterpret_cast<std::uint8_t>(obj_)))
#elif (QS_OBJ_PTR_SIZE == 2U)
    #define QS_OBJ(obj_) (QP::QS::u16_fmt_(QP::QS::OBJ_T, \
        reinterpret_cast<std::uint16_t>(obj_)))
#elif (QS_OBJ_PTR_SIZE == 4U)
    #define QS_OBJ(obj_) (QP::QS::u32_fmt_(QP::QS::OBJ_T, \
        reinterpret_cast<std::uint32_t>(obj_)))
#elif (QS_OBJ_PTR_SIZE == 8U)
    #define QS_OBJ(obj_) (QP::QS::u64_fmt_(QP::QS::OBJ_T, \
        reinterpret_cast<std::uint64_t>(obj_)))
#else
    #define QS_OBJ(obj_) (QP::QS::u32_fmt_(QP::QS::OBJ_T, \
        reinterpret_cast<std::uint32_t>(obj_)))
#endif
 
 
#if (QS_FUN_PTR_SIZE == 1U)
    #define QS_FUN(fun_) (QP::QS::u8_fmt_(QP::QS::FUN_T, \
        reinterpret_cast<std::uint8_t>(fun_)))
#elif (QS_FUN_PTR_SIZE == 2U)
    #define QS_FUN(fun_) (QP::QS::u16_fmt_(QP::QS::FUN_T, \
        reinterpret_cast<std::uint16_t>(fun_)))
#elif (QS_FUN_PTR_SIZE == 4U)
    #define QS_FUN(fun_) (QP::QS::u32_fmt_(QP::QS::FUN_T, \
        reinterpret_cast<std::uint32_t>(fun_)))
#elif (QS_FUN_PTR_SIZE == 8U)
    #define QS_FUN(fun_) (QP::QS::u64_fmt_(QP::QS::FUN_T, \
        reinterpret_cast<std::uint64_t>(fun_)))
#else
    #define QS_FUN(fun_) (QP::QS::u32_fmt_(QP::QS::FUN_T, \
        reinterpret_cast<std::uint32_t>(fun_)))
#endif
 
 
#if (Q_SIGNAL_SIZE == 1U)
    #define QS_SIG(sig_, obj_) \
        QP::QS::u8_fmt_(QP::QS::SIG_T, static_cast<std::uint8_t>(sig_)); \
        QP::QS::obj_raw_(obj_)
#elif (Q_SIGNAL_SIZE == 2U)
    #define QS_SIG(sig_, obj_) \
        QP::QS::u16_fmt_(QP::QS::SIG_T, static_cast<std::uint16_t>(sig_)); \
        QP::QS::obj_raw_(obj_)
#elif (Q_SIGNAL_SIZE == 4U)
    #define QS_SIG(sig_, obj_) \
        QP::QS::u32_fmt_(QP::QS::SIG_T, static_cast<std::uint32_t>(sig_)); \
        QP::QS::obj_raw_(obj_)
#else
    #define QS_SIG(sig_, obj_) \
        QP::QS::u16_fmt_(QP::QS::SIG_T, static_cast<std::uint16_t>(sig_)); \
        QP::QS::obj_raw_(obj_)
#endif
 
 
 
#define QS_SIG_DICTIONARY(sig_, obj_) \
    (QP::QS::sig_dict_pre_((sig_), (obj_), #sig_))
 
#define QS_OBJ_DICTIONARY(obj_) \
    (QP::QS::obj_dict_pre_((obj_), #obj_))
 
#define QS_FUN_DICTIONARY(fun_) \
    (QP::QS::fun_dict_pre_(     \
        QP::QS::force_cast<void (*)(void)>(fun_), #fun_))
 
#define QS_USR_DICTIONARY(rec_) do {              \
    static char_t const usr_name_[] = #rec_;      \
    QP::QS::usr_dict_pre_((rec_), &usr_name_[0]); \
} while (false)
 
#define QS_ASSERTION(module_, loc_, delay_) \
    (QP::QS::assertion_pre_((module_), (loc_), (delay_)))
 
#define QF_QS_CRIT_ENTRY() (QP::QS::crit_entry_pre_())
 
#define QF_QS_CRIT_EXIT()  (QP::QS::crit_exit_pre_())
 
#define QF_QS_ISR_ENTRY(isrnest_, prio_) \
    (QP::QS::isr_entry_pre_((isrnest_), (prio_)))
 
#define QF_QS_ISR_EXIT(isrnest_, prio_) \
    (QP::QS::isr_exit_pre_((isrnest_), (prio_)))
 
#define QS_FLUSH()   (QP::QS::onFlush())
 
#define QF_QS_ACTION(act_)      (act_)
 
#define QS_OUTPUT()   (QS_output())
 
#define QS_RX_INPUT() (QS_rx_input())
 
 
//****************************************************************************
// Macros for use in QUTest only
 
#ifdef Q_UTEST
    #define QS_TEST_PROBE_DEF(fun_)                                       \
        std::uint32_t const qs_tp_ =                                      \
            QP::QS::getTestProbe_(QP::QS::force_cast<void (*)(void)>(fun_));
 
    #define QS_TEST_PROBE(code_)  \
        if (qs_tp_ != 0U) { code_ }
 
    #define QS_TEST_PROBE_ID(id_, code_)                       \
        if (qs_tp_ == static_cast<std::uint32_t>(id_)) { code_ }
 
    #define QS_TEST_PAUSE() do {                                 \
        QP::QS::beginRec_(                                       \
            static_cast<std::uint_fast8_t>(QP::QS_TEST_PAUSED)); \
        QP::QS::endRec_();                                       \
        QP::QS::onTestLoop();                                    \
    } while (false)
 
#else
    // dummy definitions when not building for QUTEST
    #define QS_TEST_PROBE_DEF(fun_)
    #define QS_TEST_PROBE(code_)
    #define QS_TEST_PROBE_ID(id_, code_)
    #define QS_TEST_PAUSE()  ((void)0)
#endif // Q_UTEST
 
#endif // QS_HPP