qep.h

Go to the documentation of this file.

 
#ifndef QEP_H
#define QEP_H
 
/****************************************************************************/
#define QP_VERSION      682U
 
#define QP_VERSION_STR  "6.8.2"
 
#define QP_RELEASE      0x886A47F5U
 
 
/****************************************************************************/
/* typedefs for basic numerical types; MISRA-C 2004 rule 6.3(req). */
 
typedef char char_t;
 
typedef int int_t;
 
typedef unsigned uint_t;
 
typedef int enum_t;
 
typedef float float32_t;
 
typedef double float64_t;
 
extern char_t const QP_versionStr[7];
 
/****************************************************************************/
#ifndef Q_SIGNAL_SIZE
 
    #define Q_SIGNAL_SIZE 2U
#endif
#if (Q_SIGNAL_SIZE == 1U)
    typedef uint8_t QSignal;
#elif (Q_SIGNAL_SIZE == 2U)
 
    typedef uint16_t QSignal;
#elif (Q_SIGNAL_SIZE == 4U)
    typedef uint32_t QSignal;
#else
    #error "Q_SIGNAL_SIZE defined incorrectly, expected 1U, 2U, or 4U"
#endif
 
 
/****************************************************************************/
typedef struct {
    QSignal sig;              
    uint8_t poolId_;          
    uint8_t volatile refCtr_; 
} QEvt;
 
#ifdef Q_EVT_CTOR /* Shall the constructor for the QEvt class be provided? */
 
QEvt *QEvt_ctor(QEvt * const me, enum_t const sig);
 
#endif
 
/****************************************************************************/
#define Q_HSM_UPCAST(ptr_) ((QHsm *)(ptr_))
 
#define Q_EVT_CAST(class_) ((class_ const *)e)
 
#define Q_UINT2PTR_CAST(type_, uintptr_)  ((type_ *)(uintptr_))
 
 
/****************************************************************************/
typedef uint_fast8_t QState;
 
/* forward declaration */
typedef struct QXThread QXThread;
 
typedef QState (*QStateHandler)(void * const me, QEvt const * const e);
 
typedef QState (*QActionHandler)(void * const me);
 
typedef void (*QXThreadHandler)(QXThread * const me);
 
#define Q_STATE_CAST(handler_)  ((QStateHandler)(handler_))
 
#define Q_ACTION_CAST(action_)  ((QActionHandler)(action_))
 
/* forward declarations... */
struct QMState;
struct QHsmVtable;
typedef struct QMTranActTable QMTranActTable;
 
union QHsmAttr {
    QStateHandler   fun;         
    QActionHandler  act;         
    QXThreadHandler thr;         
    struct QMState const *obj;   
    QMTranActTable const *tatbl; 
};
 
/****************************************************************************/
typedef struct {
    struct QHsmVtable const *vptr; 
    union QHsmAttr state; 
    union QHsmAttr temp;  
} QHsm;
 
struct QHsmVtable {
    void (*init)(QHsm * const me, void const * const e);
 
    void (*dispatch)(QHsm * const me, QEvt const * const e);
};
 
/* QHsm public operations... */
#define QHSM_INIT(me_, par_) do {        \
    Q_ASSERT((me_)->vptr);               \
    (*(me_)->vptr->init)((me_), (par_)); \
} while (false)
 
void QHsm_init_(QHsm * const me, void const * const e);
 
#define QHSM_DISPATCH(me_, e_) ((*(me_)->vptr->dispatch)((me_), (e_)))
 
void QHsm_dispatch_(QHsm * const me, QEvt const * const e);
 
#define QHsm_state(me_) (Q_STATE_CAST(Q_HSM_UPCAST(me_)->state.fun))
 
#define QHsm_childState(me_, parent_) \
    QHsm_childState_(Q_HSM_UPCAST(me_), Q_STATE_CAST(parent_))
 
bool QHsm_isIn(QHsm * const me, QStateHandler const state);
 
/* QHsm protected operations... */
void QHsm_ctor(QHsm * const me, QStateHandler initial);
 
QState QHsm_top(void const * const me, QEvt const * const e);
 
/* QHsm private operations... */
QStateHandler QHsm_childState_(QHsm * const me,
                               QStateHandler const parent);
 
 
/****************************************************************************/
typedef struct {
    QHsm super; 
} QMsm;
 
struct QMState {
    struct QMState const *superstate;   
    QStateHandler  const stateHandler;  
    QActionHandler const entryAction;   
    QActionHandler const exitAction;    
    QActionHandler const initAction;    
};
typedef struct QMState QMState;
 
struct QMTranActTable {
    struct QMState const *target;
    QActionHandler const act[1];
};
 
/* QMsm public operations... */
#define QMsm_stateObj(me_) (Q_HSM_UPCAST(me_)->state.obj)
 
#define QMsm_childStateObj(me_, parent_) \
    QMsm_childStateObj_(Q_HSM_UPCAST(me_), (parent_))
 
QMState const *QMsm_childStateObj_(QMsm const * const me,
                                   QMState const * const parent);
 
bool QMsm_isInState(QMsm const * const me, QMState const * const state);
 
/* QMsm protected operations... */
void QMsm_ctor(QMsm * const me, QStateHandler initial);
 
/* QMsm private operations... */
void QMsm_init_(QHsm * const me, void const * const e);
 
void QMsm_dispatch_(QHsm * const me, QEvt const * const e);
 
 
#define Q_TRAN(target_)  \
    ((Q_HSM_UPCAST(me))->temp.fun = Q_STATE_CAST(target_), (QState)Q_RET_TRAN)
 
#define Q_TRAN_HIST(hist_)  \
    ((Q_HSM_UPCAST(me))->temp.fun = (hist_), (QState)Q_RET_TRAN_HIST)
 
#define Q_SUPER(super_)  \
    ((Q_HSM_UPCAST(me))->temp.fun = Q_STATE_CAST(super_), (QState)Q_RET_SUPER)
 
#define Q_HANDLED()      ((QState)Q_RET_HANDLED)
 
#define Q_UNHANDLED()    ((QState)Q_RET_UNHANDLED)
 
#define Q_ACTION_NULL    ((QActionHandler)0)
 
 
/****************************************************************************/
enum {
    /* unhandled and need to "bubble up" */
    Q_RET_SUPER,     
    Q_RET_SUPER_SUB, 
    Q_RET_UNHANDLED, 
    /* handled and do not need to "bubble up" */
    Q_RET_HANDLED,   
    Q_RET_IGNORED,   
    /* entry/exit */
    Q_RET_ENTRY,     
    Q_RET_EXIT,      
    /* no side effects */
    Q_RET_NULL,      
    /* transitions need to execute transition-action table in ::QMsm */
    Q_RET_TRAN,      
    Q_RET_TRAN_INIT, 
    Q_RET_TRAN_EP,   
    /* transitions that additionally clobber me->state */
    Q_RET_TRAN_HIST, 
    Q_RET_TRAN_XP    
};
 
#ifdef Q_SPY
 
    #define QM_ENTRY(state_) \
        ((Q_HSM_UPCAST(me))->temp.obj = (state_), (QState)Q_RET_ENTRY)
 
    #define QM_EXIT(state_) \
        ((Q_HSM_UPCAST(me))->temp.obj = (state_), (QState)Q_RET_EXIT)
 
#else
    #define QM_ENTRY(dummy) ((QState)Q_RET_ENTRY)
 
    #define QM_EXIT(dummy)  ((QState)Q_RET_EXIT)
 
#endif /* Q_SPY */
 
#define QM_SM_EXIT(state_) \
    ((Q_HSM_UPCAST(me))->temp.obj = (state_), (QState)Q_RET_EXIT)
 
#define QM_TRAN(tatbl_) ((Q_HSM_UPCAST(me))->temp.tatbl \
      = (QMTranActTable *)(tatbl_), (QState)Q_RET_TRAN)
 
#define QM_TRAN_INIT(tatbl_) ((Q_HSM_UPCAST(me))->temp.tatbl \
    = (QMTranActTable *)(tatbl_), (QState)Q_RET_TRAN_INIT)
 
#define QM_TRAN_HIST(history_, tatbl_)                                 \
    ((((Q_HSM_UPCAST(me))->state.obj = (history_)),                    \
       ((Q_HSM_UPCAST(me))->temp.tatbl = (QMTranActTable *)(tatbl_))), \
     (QState)Q_RET_TRAN_HIST)
 
#define QM_TRAN_EP(tatbl_) ((Q_HSM_UPCAST(me))->temp.tatbl \
    = (struct QMTranActTable *)(tatbl_), (QState)Q_RET_TRAN_EP)
 
#define QM_TRAN_XP(xp_, tatbl_)                                        \
    ((((Q_HSM_UPCAST(me))->state.act = (xp_)),                         \
       ((Q_HSM_UPCAST(me))->temp.tatbl = (QMTranActTable *)(tatbl_))), \
     (QState)Q_RET_TRAN_XP)
 
#define QM_HANDLED()     ((QState)Q_RET_HANDLED)
 
#define QM_UNHANDLED()   ((QState)Q_RET_UNHANDLED)
 
#define QM_SUPER()       ((QState)Q_RET_SUPER)
 
#define QM_SUPER_SUB(host_) \
    ((Q_HSM_UPCAST(me))->temp.obj = (host_), (QState)Q_RET_SUPER_SUB)
 
#define QM_STATE_NULL    ((QMState *)0)
 
enum {
    Q_ENTRY_SIG = 1,  
    Q_EXIT_SIG,       
    Q_INIT_SIG,       
    Q_USER_SIG        
};
 
#endif /* QEP_H */