QP/C  6.0.2
macros.h File Reference

Command-line macros and macros for porting QP. More...

Go to the source code of this file.

Macros

#define Q_NASSERT
 The preprocessor switch to disable checking assertions. More...
 
#define Q_SPY
 The preprocessor switch to activate the QS software tracing instrumentation in the code. More...
 
#define QF_OS_OBJECT_TYPE   uint8_t
 This macro defines the type of the OS-Object used for blocking the native QF event queue when the queue is empty. More...
 
#define QF_THREAD_TYPE   void *
 This macro defines the type of the thread handle used for the active objects. More...
 
#define QACTIVE_EQUEUE_WAIT_(me_)   (Q_ASSERT((me_)->eQueue.frontEvt != (QEvt *)0))
 Platform-dependent macro defining how QF should block the calling task when the QF native queue is empty. More...
 
#define QACTIVE_EQUEUE_SIGNAL_(me_)
 
#define QF_EPOOL_TYPE_   QMPool
 This macro defines the type of the event pool used in the QK kernel. More...
 
#define QF_EPOOL_INIT_(p_, poolSto_, poolSize_, evtSize_)   (QMPool_init(&(p_), (poolSto_), (poolSize_), (QMPoolSize)(evtSize_)))
 Platform-dependent macro defining the event pool initialization. More...
 
#define QF_EPOOL_EVENT_SIZE_(p_)   ((QEvtSize)(p_).blockSize)
 Platform-dependent macro defining how QF should obtain the event pool block-size. More...
 
#define QF_EPOOL_GET_(p_, e_, m_)   ((e_) = (QEvt *)QMPool_get(&(p_), (m_)))
 Platform-dependent macro defining how QF should obtain an event e_ from the event pool p_ with the free margin m_. More...
 
#define QF_EPOOL_PUT_(p_, e_)   (QMPool_put(&(p_), (e_)))
 Platform-dependent macro defining how QF should return an event e_ to the event pool p_. More...
 
#define WIN32_GUI
 Macro that should be defined (typically on the compiler's command line) in the Win32-GUI applications that use the Win32 API (Windows) or Win32-QV (Windows with QV) ports.
 

Detailed Description

Command-line macros and macros for porting QP.

Definition in file macros.h.

Macro Definition Documentation

◆ Q_NASSERT

#define Q_NASSERT

The preprocessor switch to disable checking assertions.

When defined, Q_NASSERT disables the following macros Q_ASSERT, Q_REQUIRE, Q_ENSURE, Q_INVARIANT, Q_ERROR as well as Q_ASSERT_ID, Q_REQUIRE_ID, Q_ENSURE_ID, Q_INVARIANT_ID, and Q_ERROR_ID do not evaluate the test condition passed as the argument to these macros.

Note
The notable exceptions are the macros Q_ALLEGE and Q_ALLEGE_ID, that still evaluate the test condition, but do not report assertion failures when the switch Q_NASSERT is defined.

Definition at line 18 of file macros.h.

◆ Q_SPY

#define Q_SPY

The preprocessor switch to activate the QS software tracing instrumentation in the code.

When defined, Q_SPY activates the QS software tracing instrumentation. When Q_SPY is not defined, the QS instrumentation in the code does not generate any code.

Definition at line 27 of file macros.h.

◆ QF_OS_OBJECT_TYPE

#define QF_OS_OBJECT_TYPE   uint8_t

This macro defines the type of the OS-Object used for blocking the native QF event queue when the queue is empty.

In QK, the OS object is used to hold the per-thread flags, which might be used, for example, to remember the thread attributes (e.g., if the thread uses a floating point co-processor). The OS object value is set on per-thread basis in QActive_start(). Later, the extended context switch macros (QK_EXT_SAVE() and QK_EXT_RESTORE()) might use the per-thread flags to determine what kind of extended context switch this particular thread needs (e.g., the thread might not be using the coprocessor or might be using a different one).

Definition at line 41 of file macros.h.

◆ QF_THREAD_TYPE

#define QF_THREAD_TYPE   void *

This macro defines the type of the thread handle used for the active objects.

Definition at line 45 of file macros.h.

◆ QACTIVE_EQUEUE_WAIT_

#define QACTIVE_EQUEUE_WAIT_ (   me_)    (Q_ASSERT((me_)->eQueue.frontEvt != (QEvt *)0))

Platform-dependent macro defining how QF should block the calling task when the QF native queue is empty.

Note
This is just an example of QACTIVE_EQUEUE_WAIT_() for the QK-port of QF. QK never activates a task that has no events to process, so in this case the macro asserts that the queue is not empty. In other QF ports you need to define the macro appropriately for the underlying kernel/OS you're using.

Definition at line 56 of file macros.h.

◆ QACTIVE_EQUEUE_SIGNAL_

#define QACTIVE_EQUEUE_SIGNAL_ (   me_)
Value:
do { \
QPSet8_insert(&QK_readySet_, (me_)->prio); \
if (QK_intNest_ == (uint_fast8_t)0) { \
uint_fast8_t p = QK_schedPrio_(); \
if (p != (uint_fast8_t)0) { \
QK_sched_(p); \
} \
} \
} while (0)
uint8_t prio
QF priority (1..QF_MAX_ACTIVE) of this active object.
Definition: qf.h:153
unsigned int uint_fast8_t
fast at-least 8-bit unsigned int
Definition: stdint.h:35

Definition at line 60 of file macros.h.

◆ QF_EPOOL_TYPE_

#define QF_EPOOL_TYPE_   QMPool

This macro defines the type of the event pool used in the QK kernel.

Note
This is a specific implementation for the QK-port of QF. In other QF ports you need to define the macro appropriately for the underlying kernel/OS you're using.

Definition at line 101 of file macros.h.

◆ QF_EPOOL_INIT_

#define QF_EPOOL_INIT_ (   p_,
  poolSto_,
  poolSize_,
  evtSize_ 
)    (QMPool_init(&(p_), (poolSto_), (poolSize_), (QMPoolSize)(evtSize_)))

Platform-dependent macro defining the event pool initialization.

Note
This is a specific implementation for the QK-port of QF. In other QF ports you need to define the macro appropriately for the underlying kernel/OS you're using.

Definition at line 109 of file macros.h.

◆ QF_EPOOL_EVENT_SIZE_

#define QF_EPOOL_EVENT_SIZE_ (   p_)    ((QEvtSize)(p_).blockSize)

Platform-dependent macro defining how QF should obtain the event pool block-size.

Note
This is a specific implementation for the QK-port of QF. In other QF ports you need to define the macro appropriately for the underlying kernel/OS you're using.

Definition at line 119 of file macros.h.

◆ QF_EPOOL_GET_

#define QF_EPOOL_GET_ (   p_,
  e_,
  m_ 
)    ((e_) = (QEvt *)QMPool_get(&(p_), (m_)))

Platform-dependent macro defining how QF should obtain an event e_ from the event pool p_ with the free margin m_.

Note
This is a specific implementation for the QK-port of QF. In other QF ports you need to define the macro appropriately for the underlying kernel/OS you're using.

Definition at line 128 of file macros.h.

◆ QF_EPOOL_PUT_

#define QF_EPOOL_PUT_ (   p_,
  e_ 
)    (QMPool_put(&(p_), (e_)))

Platform-dependent macro defining how QF should return an event e_ to the event pool p_.

Note
This is a specific implementation for the QK-port of QF. In other QF ports you need to define the macro appropriately for the underlying kernel/OS you're using.

Definition at line 137 of file macros.h.