qep.h

Go to the documentation of this file.

#ifndef qep_h
#define qep_h

/****************************************************************************/
#define QP_VERSION      651U

#define QP_VERSION_STR  "6.5.1"

#define QP_RELEASE      0x8E7055B4U


/****************************************************************************/
/* typedefs for basic numerical types; MISRA-C 2004 rule 6.3(req). */

typedef char char_t;

typedef int int_t;

typedef int enum_t;

typedef float float32_t;

typedef double float64_t;


extern char_t const QP_versionStr[7];

#define QEP_getVersion() (QP_versionStr)


/****************************************************************************/
#ifndef Q_SIGNAL_SIZE

    #define Q_SIGNAL_SIZE 2
#endif
#if (Q_SIGNAL_SIZE == 1)
    typedef uint8_t QSignal;
#elif (Q_SIGNAL_SIZE == 2)

    typedef uint16_t QSignal;
#elif (Q_SIGNAL_SIZE == 4)
    typedef uint32_t QSignal;
#else
    #error "Q_SIGNAL_SIZE defined incorrectly, expected 1, 2, or 4"
#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_, uint_)  ((type_ *)(uint_))


/****************************************************************************/
typedef uint_fast8_t QState;

typedef QState (*QStateHandler)(void * const me, QEvt const * const e);

typedef QState (*QActionHandler)(void * const me);

#define Q_STATE_CAST(handler_)  ((QStateHandler)(handler_))

#define Q_ACTION_CAST(action_)  ((QActionHandler)(action_))

/* forward declarations... */
struct QMState;
struct QMTranActTable;
struct QHsmVtbl;

union QHsmAttr {
    QStateHandler  fun;          
    QActionHandler act;          
    struct QMState const *obj;   
    struct QMTranActTable const *tatbl; 
};

/****************************************************************************/
/* Hierarchical State Machine */

typedef struct {
    struct QHsmVtbl const *vptr; 
    union QHsmAttr state; 
    union QHsmAttr temp;  
} QHsm;

struct QHsmVtbl {
    void (*init)(QHsm * const me, QEvt const * const e);

    void (*dispatch)(QHsm * const me, QEvt const * const e);
};

void QHsm_ctor(QHsm * const me, QStateHandler initial);

#define QHSM_INIT(me_, e_) do {        \
    Q_ASSERT((me_)->vptr);             \
    (*(me_)->vptr->init)((me_), (e_)); \
} while (0)

void QHsm_init_(QHsm * const me, QEvt 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_))

QStateHandler QHsm_childState_(QHsm * const me,
                               QStateHandler const parent);

bool QHsm_isIn(QHsm * const me, QStateHandler const state);

/* protected methods */

QState QHsm_top(void const * const me, QEvt const * const e);


/****************************************************************************/
typedef QHsm QMsm;

typedef struct QHsmVtbl QMsmVtbl;

typedef struct QMState {
    struct QMState const *superstate;   
    QStateHandler  const stateHandler;  
    QActionHandler const entryAction;   
    QActionHandler const exitAction;    
    QActionHandler const initAction;    
} QMState;

typedef struct QMTranActTable {
    QMState const *target;
    QActionHandler const act[1];
} QMTranActTable;

void QMsm_ctor(QMsm * const me, QStateHandler initial);

void QMsm_init_(QMsm * const me, QEvt const * const e);

void QMsm_dispatch_(QMsm * const me, QEvt const * const e);

#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);

#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 const *)(tatbl_), \
        (QState)Q_RET_TRAN)

#define QM_TRAN_INIT(tatbl_)                                            \
    ((Q_HSM_UPCAST(me))->temp.tatbl = (QMTranActTable const *)(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 const *)(tatbl_))), \
       (QState)Q_RET_TRAN_HIST)

#define QM_TRAN_EP(tatbl_) \
    ((Q_HSM_UPCAST(me))->temp.tatbl = (QMTranActTable const *)(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 const *)(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 const *)0)

enum {
    Q_ENTRY_SIG = 1,  
    Q_EXIT_SIG,       
    Q_INIT_SIG,       
    Q_USER_SIG        
};

#endif /* qep_h */