QP/C++  7.4.0-rc.1
Real-Time Embedded Framework
Loading...
Searching...
No Matches
qp.hpp File Reference

QP/C++ platform-independent public interface. More...

Go to the source code of this file.

Classes

class  QP::QEvt
 Event class. More...
 
struct  QP::QMState
 State object for the QP::QMsm class (QM State Machine). More...
 
struct  QP::QMTranActTable
 Transition-Action Table for the QP::QMsm State Machine. More...
 
union  QP::QAsmAttr
 Attribute of for the QP::QAsm class (Abstract State Machine). More...
 
class  QP::QAsm
 Abstract State Machine class (state machine interface) More...
 
class  QP::QHsm
 Hierarchical State Machine class (QHsm-style state machine implementation strategy) More...
 
class  QP::QMsm
 Hierarchical State Machine class (QMsm-style state machine implementation strategy) More...
 
class  QP::QPSet
 Set of Active Objects of up to QF_MAX_ACTIVE elements. More...
 
class  QP::QSubscrList
 Subscriber List (for publish-subscribe) More...
 
class  QP::QActive
 Active object class (based on the QHsm implementation strategy) More...
 
class  QP::QMActive
 Active object class (based on QMsm implementation strategy) More...
 
class  QP::QTimeEvt
 Time Event class. More...
 
class  QP::QTicker
 "Ticker" Active Object class More...
 

Namespaces

namespace  QP
 QP/C++ framework.
 
namespace  QP::QF
 QF Active Object Framework.
 

Macros

#define QP_VERSION_STR   "7.4.0-rc.1"
 
#define QP_VERSION   740U
 
#define QP_RELEASE   0x7092C3BBU
 
#define Q_STATE_DECL(state_)
 
#define Q_STATE_DEF(subclass_, state_)
 
#define Q_HANDLED()   (Q_RET_HANDLED)
 
#define Q_UNHANDLED()   (Q_RET_UNHANDLED)
 
#define Q_EVT_CAST(subclass_)   (static_cast<subclass_ const *>(e))
 
#define Q_STATE_CAST(handler_)    (reinterpret_cast<QP::QStateHandler>(handler_))
 
#define QM_STATE_DECL(state_)
 
#define QM_SM_STATE_DECL(subm_, state_)
 
#define QM_ACTION_DECL(action_)
 
#define QM_STATE_DEF(subclass_, state_)
 
#define QM_ACTION_DEF(subclass_, action_)
 
#define QM_HANDLED()   (Q_RET_HANDLED)
 
#define QM_UNHANDLED()   (Q_RET_HANDLED)
 
#define QM_SUPER()   (Q_RET_SUPER)
 
#define QM_STATE_NULL   (nullptr)
 
#define Q_ACTION_NULL   (nullptr)
 
#define Q_UNUSED_PAR(par_)   (static_cast<void>(par_))
 
#define Q_DIM(array_)   (sizeof(array_) / sizeof((array_)[0U]))
 
#define Q_UINT2PTR_CAST(type_, uint_)   (reinterpret_cast<type_ *>(uint_))
 
#define INIT(qsId_)   init((qsId_))
 
#define DISPATCH(e_, qsId_)   dispatch((e_), (qsId_))
 
#define Q_PRIO(prio_, pthre_)    (static_cast<QP::QPrioSpec>((prio_) | (pthre_) << 8U))
 
#define Q_NEW(evtT_, sig_)   (QP::QF::q_new<evtT_>((sig_)))
 
#define Q_NEW_X(evtT_, margin_, sig_)   (QP::QF::q_new_x<evtT_>((margin_), (sig_)))
 
#define Q_NEW_REF(evtRef_, evtT_)   (QP::QF::q_new_ref<evtT_>(e, (evtRef_)))
 
#define Q_DELETE_REF(evtRef_)
 
#define PUBLISH(e_, sender_)    publish_((e_), (sender_), (sender_)->getPrio())
 
#define POST(e_, sender_)   post_((e_), QP::QF::NO_MARGIN, (sender_))
 
#define POST_X(e_, margin_, sender_)    post_((e_), (margin_), (sender_))
 
#define TICK_X(tickRate_, sender_)   tick((tickRate_), (sender_))
 
#define TICK(sender_)   TICK_X(0U, (sender_))
 
#define TRIG(sender_)   trig_((sender_))
 
#define QF_CRIT_EXIT_NOP()   (static_cast<void>(0))
 
#define QF_MEM_SYS()   (static_cast<void>(0))
 
#define QF_MEM_APP()   (static_cast<void>(0))
 

Typedefs

using int_t = int
 
using enum_t = int
 
using float32_t = float
 
using float64_t = double
 
using QP::QSignal = std::uint16_t
 
using QP::QState = std::uint_fast8_t
 
using QP::QStateHandler = QState (*)(void * const me, QEvt const * const e)
 
using QP::QActionHandler = QState (*)(void * const me)
 
using QP::QXThreadHandler = void (*)(QXThread * const me)
 
using QP::QPrioSpec = std::uint16_t
 
using QP::QTimeEvtCtr = std::uint32_t
 
using QP::QPSetBits = std::uint32_t
 

Functions

std::uint_fast8_t QP::QF_LOG2 (QP::QPSetBits x) noexcept
 
void QP::QF::init ()
 
void QP::QF::stop ()
 
int_t QP::QF::run ()
 
void QP::QF::onStartup ()
 
void QP::QF::onCleanup ()
 
void QP::QF::psInit (QSubscrList *const subscrSto, enum_t const maxSignal) noexcept
 
void QP::QF::publish_ (QEvt const *const e, void const *const sender, std::uint_fast8_t const qsId) noexcept
 
void QP::QF::tick (std::uint_fast8_t const tickRate, void const *const sender) noexcept
 
std::uint_fast16_t QP::QF::getQueueMin (std::uint_fast8_t const prio) noexcept
 
void QP::QF::poolInit (void *const poolSto, std::uint_fast32_t const poolSize, std::uint_fast16_t const evtSize) noexcept
 
std::uint_fast16_t QP::QF::poolGetMaxBlockSize () noexcept
 
std::uint_fast16_t QP::QF::getPoolMin (std::uint_fast8_t const poolNum) noexcept
 
QEvtQP::QF::newX_ (std::uint_fast16_t const evtSize, std::uint_fast16_t const margin, enum_t const sig) noexcept
 
void QP::QF::gc (QEvt const *const e) noexcept
 
QEvt const * QP::QF::newRef_ (QEvt const *const e, QEvt const *const evtRef) noexcept
 
void QP::QF::deleteRef_ (QEvt const *const evtRef) noexcept
 
template<class evtT_ >
evtT_ * QP::QF::q_new (enum_t const sig)
 
template<class evtT_ >
evtT_ * QP::QF::q_new_x (std::uint_fast16_t const margin, enum_t const sig)
 
template<class evtT_ >
void QP::QF::q_new_ref (QP::QEvt const *const e, evtT_ const *&evtRef)
 
template<class evtT_ >
void QP::QF::q_delete_ref (evtT_ const *&evtRef)
 
QEvtQP::QF::newXfromISR_ (std::uint_fast16_t const evtSize, std::uint_fast16_t const margin, enum_t const sig) noexcept
 
void QP::QF::gcFromISR (QEvt const *e) noexcept
 
void QF_onContextSw (QP::QActive *prev, QP::QActive *next)
 

Variables

constexpr char const QP::versionStr [] {QP_VERSION_STR}
 
constexpr enum_t QP::Q_USER_SIG {4}
 
constexpr std::uint_fast16_t QP::QF::NO_MARGIN {0xFFFFU}
 

Detailed Description

QP/C++ platform-independent public interface.

Definition in file qp.hpp.

Macro Definition Documentation

◆ QP_VERSION_STR

#define QP_VERSION_STR   "7.4.0-rc.1"

Version string complying with Semantic Versioning

Description
QP_VERSION_STR is a zero-terminated version string in the form MAJOR.MINOR.PATCH compliant with Semantic Versioning.
Examples:
  • 7.3.5-rc.1 — version 7.3.5 release-candidate-1
  • 7.3.5 — version 7.3.5 (final release)

Definition at line 47 of file qp.hpp.

◆ QP_VERSION

#define QP_VERSION   740U

Version number for internal use (must correspond to QP_VERSION_STR)

Description
QP_VERSION is an unsigned integer constant of the form MAJOR|MINOR|PATCH corresponding to QP_VERSION_STR, with digits merged together. For example QP_VERSION_STR == "7.3.5-rc.1" results in QP_VERSION == 735.

Definition at line 48 of file qp.hpp.

◆ QP_RELEASE

#define QP_RELEASE   0x7092C3BBU

Encrypted current QP release for internal use (7.3.5 on 2024-05-31)

Description
QP_RELEASE contains information about QP_VERSION (e.g., 735) and release date (e.g., 2023-06-30).

Definition at line 49 of file qp.hpp.

◆ Q_STATE_DECL

#define Q_STATE_DECL ( state_)
Value:
QP::QState state_ ## _h(QP::QEvt const * const e); \
static QP::QState state_(void * const me, QP::QEvt const * const e)
Event class.
Definition qp.hpp:137
std::uint_fast8_t QState
Definition qp.hpp:171

Definition at line 471 of file qp.hpp.

◆ Q_STATE_DEF

#define Q_STATE_DEF ( subclass_,
state_ )
Value:
QP::QState subclass_::state_(void * const me, QP::QEvt const * const e) { \
return static_cast<subclass_ *>(me)->state_ ## _h(e); } \
QP::QState subclass_::state_ ## _h(QP::QEvt const * const e)

Definition at line 476 of file qp.hpp.

◆ Q_HANDLED

#define Q_HANDLED ( )    (Q_RET_HANDLED)

Indicate that an action has been "handled". Applies to entry/exit actions and to internal transitions in QP::QHsm state machines.

Traceability
Usage
Q_STATE_DEF(ToasterOven, toasting) {
QP::QState status_;
switch (e->sig) {
case Q_ENTRY_SIG: {
PRINTF_S("%s;", "toasting");
status_ = Q_HANDLED(); // <===
break;
}
. . .
}
return status_;
}
#define Q_STATE_DEF(subclass_, state_)
Definition qp.hpp:476
#define Q_HANDLED()
Definition qp.hpp:482

Definition at line 482 of file qp.hpp.

◆ Q_UNHANDLED

#define Q_UNHANDLED ( )    (Q_RET_UNHANDLED)

Indicate that an internal transition has been "unhandled" due to a guard condition. Applies to internal transitions in QP::QHsm state machines.

Description
This macro must be called when a state-handler attempts to handle an event but a guard condition evaluates to 'false' and there is no other explicit way of handling the event. Applicable only to QP::QHsm subclasses.
Usage
Q_STATE_DEF(Philo, hungry) {
QP::QState status_;
switch (e->sig) {
. . .
case EAT_SIG: {
if (Q_EVT_CAST(TableEvt)->philoId == m_id) {
status_ = tran(&eating);
}
else {
status_ = Q_UNHANDLED(); // <===
}
break;
}
. . .
}
return status_;
}
#define Q_EVT_CAST(subclass_)
Definition qp.hpp:488
#define Q_UNHANDLED()
Definition qp.hpp:485

Definition at line 485 of file qp.hpp.

◆ Q_EVT_CAST

#define Q_EVT_CAST ( subclass_)    (static_cast<subclass_ const *>(e))

Perform downcast of an event onto a subclass of QP::QEvt class_

Description
This macro encapsulates the downcast of QP::QEvt pointers, which violates MISRA-C:2023 Rule 11.3(R). This macro helps to localize this deviation.
Parameters
subclass_a subclass of QP::QEvt
Note
The macro performs down-cast from the event pointer e.
Traceability
Usage
Q_STATE_DEF(Table, serving) {
QP::QState status_;
switch (e->sig) {
. . .
case HUNGRY_SIG: {
std::uint8_t n = Q_EVT_CAST(TableEvt)->philoId; // <===
. . .
break;
}
. . .
}
return status_;
}

Definition at line 488 of file qp.hpp.

◆ Q_STATE_CAST

#define Q_STATE_CAST ( handler_)     (reinterpret_cast<QP::QStateHandler>(handler_))

Perform cast to QP::QStateHandler.

Description
This macro encapsulates the cast of a specific state handler function pointer to QP::QStateHandler, which violates MISRA:C-2023 Rule 11.1(R). This macro helps to localize this deviation.
Parameters
handler_state handler (function pointer)
Traceability
Usage
Philo::Philo()
: QActive(Q_STATE_CAST(&initial)), // <===
m_timeEvt(this, TIMEOUT_SIG, 0U),
m_id(0xFFU)
{}
#define Q_STATE_CAST(handler_)
Definition qp.hpp:491

Definition at line 491 of file qp.hpp.

◆ QM_STATE_DECL

#define QM_STATE_DECL ( state_)
Value:
QP::QState state_ ## _h(QP::QEvt const * const e); \
static QP::QState state_(void * const me, QP::QEvt const * const e); \
static QP::QMState const state_ ## _s
State object for the QP::QMsm class (QM State Machine).
Definition qp.hpp:187

Definition at line 495 of file qp.hpp.

◆ QM_SM_STATE_DECL

#define QM_SM_STATE_DECL ( subm_,
state_ )
Value:
QP::QState state_ ## _h(QP::QEvt const * const e);\
static QP::QState state_(void * const me, QP::QEvt const * const e); \
static SM_ ## subm_ const state_ ## _s

Definition at line 501 of file qp.hpp.

◆ QM_ACTION_DECL

#define QM_ACTION_DECL ( action_)
Value:
QP::QState action_ ## _h(); \
static QP::QState action_(void * const me)

Definition at line 507 of file qp.hpp.

◆ QM_STATE_DEF

#define QM_STATE_DEF ( subclass_,
state_ )
Value:
QP::QState subclass_::state_(void * const me, QP::QEvt const * const e) {\
return static_cast<subclass_ *>(me)->state_ ## _h(e); } \
QP::QState subclass_::state_ ## _h(QP::QEvt const * const e)

Definition at line 512 of file qp.hpp.

◆ QM_ACTION_DEF

#define QM_ACTION_DEF ( subclass_,
action_ )
Value:
QP::QState subclass_::action_(void * const me) { \
return static_cast<subclass_ *>(me)->action_ ## _h(); } \
QP::QState subclass_::action_ ## _h()

Definition at line 518 of file qp.hpp.

◆ QM_HANDLED

#define QM_HANDLED ( )    (Q_RET_HANDLED)

Macro to call in a QM state-handler when it handled an event. Applicable only to QP::QMsm subclasses.

Definition at line 524 of file qp.hpp.

◆ QM_UNHANDLED

#define QM_UNHANDLED ( )    (Q_RET_HANDLED)

Indicate that an internal transition has been "unhandled" due to a guard condition. Applicable only to QP::QMsm subclasses.

Description
This macro must be called when a state-handler attempts to handle an event but a guard condition evaluates to 'false' and there is no other explicit way of handling the event.

Definition at line 527 of file qp.hpp.

◆ QM_SUPER

#define QM_SUPER ( )    (Q_RET_SUPER)

Macro to call in a QM state-handler when it designates the superstate to handle an event. Applicable only to QMSMs.

Definition at line 530 of file qp.hpp.

◆ QM_STATE_NULL

#define QM_STATE_NULL   (nullptr)

Macro to provide strictly-typed zero-state to use for submachines. Applicable to subclasses of QP::QMsm.

Definition at line 533 of file qp.hpp.

◆ Q_ACTION_NULL

#define Q_ACTION_NULL   (nullptr)

Macro to provide strictly-typed zero-action to terminate action lists in the transition-action-tables

Definition at line 536 of file qp.hpp.

◆ Q_UNUSED_PAR

#define Q_UNUSED_PAR ( par_)    (static_cast<void>(par_))

Helper macro to clearly mark unused parameters of functions.

Definition at line 539 of file qp.hpp.

◆ Q_DIM

#define Q_DIM ( array_)    (sizeof(array_) / sizeof((array_)[0U]))

Definition at line 542 of file qp.hpp.

◆ Q_UINT2PTR_CAST

#define Q_UINT2PTR_CAST ( type_,
uint_ )   (reinterpret_cast<type_ *>(uint_))

Perform cast from unsigned integer uint_ to pointer of type type_

Description
This macro encapsulates the cast to (type_ *), which QP ports or application might use to access embedded hardware registers. Such uses can trigger PC-Lint "Note 923: cast from int to pointer" and this macro helps to encapsulate this deviation.

Definition at line 545 of file qp.hpp.

◆ INIT

#define INIT ( qsId_)    init((qsId_))

Definition at line 549 of file qp.hpp.

◆ DISPATCH

#define DISPATCH ( e_,
qsId_ )   dispatch((e_), (qsId_))

Definition at line 559 of file qp.hpp.

◆ Q_PRIO

#define Q_PRIO ( prio_,
pthre_ )    (static_cast<QP::QPrioSpec>((prio_) | (pthre_) << 8U))

Create a QP::QPrioSpec object to specify priority of an AO or a thread

Parameters
[in]prio_QF priority [1..QF_MAX_ACTIVE]
[in]pthre_Preemption threshold [1..QF_MAX_ACTIVE]
Returns
The combined 16-bit priority specification (prio_ in bits [0..7] and pthre_ in bits [8..15].

Definition at line 1232 of file qp.hpp.

◆ Q_NEW

#define Q_NEW ( evtT_,
sig_ )   (QP::QF::q_new<evtT_>((sig_)))

Macro to allocate a dynamic event and asserting successful allocation.

Description
This deprecated macro is equivalent to invoking the function template QP::QF::q_new<evtT_>(sig_, ...).
Deprecated
See also
QP::QF::q_new()
Parameters
[in]evtT_event type (class name) of the event to allocate
[in]sig_signal to assign to the newly allocated event
Returns
A valid event pointer of the type evtT_*.

Definition at line 1237 of file qp.hpp.

◆ Q_NEW_X

#define Q_NEW_X ( evtT_,
margin_,
sig_ )   (QP::QF::q_new_x<evtT_>((margin_), (sig_)))

Macro to allocate a dynamic event without asserting successful allocation.

Description
This deprecated macro is equivalent to invoking the function template QP::QF::q_new_x<evtT_>(margin_, sig_, ...).
Deprecated
See also
QP::QF::q_new_x()
Parameters
[in]evtT_event type (class name) of the event to allocate
[in]margin_number of events that must remain available in the given pool after this allocation. The special value QF_NO_MARGIN causes asserting failure in case event allocation fails.
[in]sig_signal to assign to the newly allocated event
Returns
An event pointer of the type evtT_* or nullptr if the event cannot be allocated with the specified margin_ of events still left in the event pool.

Definition at line 1247 of file qp.hpp.

◆ Q_NEW_REF

#define Q_NEW_REF ( evtRef_,
evtT_ )   (QP::QF::q_new_ref<evtT_>(e, (evtRef_)))

Create a new reference of the current event e

Description
This deprecated macro is equivalent to invoking the function template QP::QF::q_new_ref<evtT_>(e, evtRef).
Deprecated
See also
QP::QF::q_new_ref()
Parameters
[in,out]evtRef_event reference to create
[in]evtT_event type (class name) of the event reference

Definition at line 1256 of file qp.hpp.

◆ Q_DELETE_REF

#define Q_DELETE_REF ( evtRef_)
Value:
do { \
QP::QF::deleteRef_((evtRef_)); \
(evtRef_) = nullptr; \
} while (false)

Delete the event reference

Description
This deprecated macro is equivalent to invoking the function template QP::QF::q_new_ref<evtT_>(e, evtRef).
Deprecated
See also
QP::QF::q_delete_ref()
Parameters
[in,out]evtRef_event reference to delete

Definition at line 1259 of file qp.hpp.

◆ PUBLISH

#define PUBLISH ( e_,
sender_ )    publish_((e_), (sender_), (sender_)->getPrio())

Publish an event to all subscriber Active Objects.

Description
If Q_SPY is defined, this macro calls QActive_publish_() with the sender_ parameter to identify the publisher of the event. Otherwise, sender_ is not used.
Parameters
[in]e_pointer to the posted event
[in]sender_pointer to the sender object (actually used only when Q_SPY is defined)
Note
The pointer to the sender_ object is not necessarily a pointer to an active object. In fact, if QACTIVE_PUBLISH() is called from an interrupt or other context, you can create a unique object just to unambiguously identify the sender of the event.

Definition at line 1266 of file qp.hpp.

◆ POST

#define POST ( e_,
sender_ )   post_((e_), QP::QF::NO_MARGIN, (sender_))

Invoke the direct event posting facility QActive_post_()

Description
This macro asserts if the queue overflows and cannot accept the event.
Parameters
[in]e_pointer to the event to post
[in]sender_pointer to the sender object.
Note
The sendedr_ parameter is actually only used when QS tracing is enabled (macro Q_SPY is defined). When QS software tracing is disabled, the QACTIVE_POST() macro does not pass the sender_ parameter, so the overhead of passing this extra parameter is entirely avoided.
The pointer to the sender object is not necessarily a pointer to an active object. In fact, if QACTIVE_POST() is called from an interrupt or other context, you can create a unique object just to unambiguously identify the sender of the event.
See also
QP::QActive::post_()
Traceability

Definition at line 1277 of file qp.hpp.

◆ POST_X

#define POST_X ( e_,
margin_,
sender_ )    post_((e_), (margin_), (sender_))

Invoke the direct event posting facility QActive_post_() without delivery guarantee

Description
This macro does not assert if the queue overflows and cannot accept the event with the specified margin of free slots remaining.
Parameters
[in]e_pointer to the event to post
[in]margin_the minimum free slots in the queue, which must still be available after posting the event. The special value QF::NO_MARGIN causes asserting failure in case event posting fails.
[in]sender_pointer to the sender object.
Returns
'true' if the posting succeeded, and 'false' if the posting failed due to insufficient margin of free entries available in the queue.
Note
The sender_ parameter is actually only used when QS tracing is enabled (macro Q_SPY is defined). When QS software tracing is disabled, the POST_X() macro does not pass the sender_ parameter, so the overhead of passing this extra parameter is entirely avoided.
The pointer to the sender object is not necessarily a pointer to an active object. In fact, if POST_X() is called from an interrupt or other context, you can create a unique object just to unambiguously identify the sender of the event.
Traceability

Definition at line 1287 of file qp.hpp.

◆ TICK_X

#define TICK_X ( tickRate_,
sender_ )   tick((tickRate_), (sender_))

Invoke the system clock tick processing QP::QTimeEvt::tick_()

Description
This macro is the recommended way of invoking clock tick processing, because it provides the vital information for software tracing and avoids any overhead when the tracing is disabled.
Parameters
[in]tickRate_clock tick rate to be serviced through this call
[in]sender_pointer to the sender object. This parameter is actually only used when QS software tracing is enabled (macro Q_SPY is defined)
Note
When QS software tracing is disabled, the macro calls QTimeEvt::tick_() without the sender parameter, so the overhead of passing this extra parameter is entirely avoided.
The pointer to the sender object is not necessarily a pointer to an active object. In fact, when TICK_X() is called from an interrupt, you would create a unique object just to unambiguously identify the ISR as the sender of the time events.

Definition at line 1298 of file qp.hpp.

◆ TICK

#define TICK ( sender_)    TICK_X(0U, (sender_))

Invoke the system clock tick processing for tick rate 0

Definition at line 1307 of file qp.hpp.

◆ TRIG

#define TRIG ( sender_)    trig_((sender_))

Asynchronously trigger the QP::QTicker::trig_() AO to perform tick processing.

Description
This macro is the recommended way to trigger clock tick processing, because it provides the vital information for software tracing and avoids any overhead when the tracing is disabled.
Parameters
[in]sender_pointer to the sender object. This parameter is actually only used when QS software tracing is enabled (macro Q_SPY is defined)
Note
When QS software tracing is disabled, the macro calls QTicker_trig_() without the sender parameter, so the overhead of passing this extra parameter is entirely avoided.
The pointer to the sender object is not necessarily a pointer to an active object. In fact, when QTICKER_TRIG() is called from an interrupt, you would create a unique object just to unambiguously identify the ISR as the sender of the time events.

Definition at line 1311 of file qp.hpp.

◆ QF_CRIT_EXIT_NOP

#define QF_CRIT_EXIT_NOP ( )    (static_cast<void>(0))

No-operation for exiting a critical section

Description
In some QF ports the critical section exit takes effect only on the next machine instruction. If this next instruction is another entry to a critical section, the critical section won't be really exited, but rather the two adjacent critical sections would be merged. The QF_CRIT_EXIT_NOP() macro contains minimal code required to prevent such merging of critical sections in such merging of critical sections in QF ports, in which it can occur.

Definition at line 1321 of file qp.hpp.

◆ QF_MEM_SYS

#define QF_MEM_SYS ( )    (static_cast<void>(0))

Definition at line 1326 of file qp.hpp.

◆ QF_MEM_APP

#define QF_MEM_APP ( )    (static_cast<void>(0))

Definition at line 1331 of file qp.hpp.

Typedef Documentation

◆ int_t

using int_t = int

Alias for assertion-ID numbers in QP assertions and return from QF_run()

Definition at line 103 of file qp.hpp.

◆ enum_t

using enum_t = int

Definition at line 106 of file qp.hpp.

◆ float32_t

using float32_t = float

Alias for IEEE 754 32-bit floating point number

Note
QP does not use floating-point types anywhere in the internal implementation, except in QS software tracing, where utilities for output of floating-point numbers are provided for application-specific trace records.

Definition at line 109 of file qp.hpp.

◆ float64_t

using float64_t = double

Alias for IEEE 754 64-bit floating point number

Note
QP does not use floating-point types anywhere in the internal implementation, except in QS software tracing, where utilities for output of floating-point numbers are provided for application-specific trace records.

Definition at line 112 of file qp.hpp.

Function Documentation

◆ QF_onContextSw()

void QF_onContextSw ( QP::QActive * prev,
QP::QActive * next )