qf_qact.c

Go to the documentation of this file.

/*$file${src::qf::qf_qact.c} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
/*
* Model: qpc.qm
* File:  ${src::qf::qf_qact.c}
*
* This code has been generated by QM 5.2.5 <www.state-machine.com/qm>.
* DO NOT EDIT THIS FILE MANUALLY. All your changes will be lost.
*
* This code is covered by the following QP license:
* License #    : LicenseRef-QL-dual
* Issued to    : Any user of the QP/C real-time embedded framework
* Framework(s) : qpc
* Support ends : 2023-12-31
* License scope:
*
* Copyright (C) 2005 Quantum Leaps, LLC <state-machine.com>.
*
* SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-QL-commercial
*
* This software is dual-licensed under the terms of the open source GNU
* General Public License version 3 (or any later version), or alternatively,
* under the terms of one of the closed source Quantum Leaps commercial
* licenses.
*
* The terms of the open source GNU General Public License version 3
* can be found at: <www.gnu.org/licenses/gpl-3.0>
*
* The terms of the closed source Quantum Leaps commercial licenses
* can be found at: <www.state-machine.com/licensing>
*
* Redistributions in source code must retain this top-level comment block.
* Plagiarizing this software to sidestep the license obligations is illegal.
*
* Contact information:
* <www.state-machine.com/licensing>
* <info@state-machine.com>
*/
/*$endhead${src::qf::qf_qact.c} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*! @file
* @brief QActive_ctor() definition
*
* @details
* This file must remain separate from the rest to avoid pulling in the
* "virtual" functions QHsm::QHsm_init_() and QHsm::QHsm_dispatch_() in
* case they are not used by the application.
*
* @sa qf_qmact.c
*/
#define QP_IMPL           /* this is QP implementation */
#include "qf_port.h"      /* QF port */
#include "qf_pkg.h"       /* QF package-scope interface */
#include "qassert.h"      /* QP embedded systems-friendly assertions */
 
Q_DEFINE_THIS_MODULE("qf_qact")
 
//============================================================================
/*$skip${QP_VERSION} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
/* Check for the minimum required QP version */
#if (QP_VERSION < 700U) || (QP_VERSION != ((QP_RELEASE^4294967295U) % 0x3E8U))
#error qpc version 7.0.0 or higher required
#endif
/*$endskip${QP_VERSION} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 
/*$define${QF::QActive::registry_[QF_MAX_ACTIVE + 1U]} vvvvvvvvvvvvvvvvvvvvv*/
QActive * QActive_registry_[QF_MAX_ACTIVE + 1U];
/*$enddef${QF::QActive::registry_[QF_MAX_ACTIVE + 1U]} ^^^^^^^^^^^^^^^^^^^^^*/
/*$define${QF::QF-pkg::readySet_} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QF::QF-pkg::readySet_} .................................................*/
QPSet QF_readySet_;
/*$enddef${QF::QF-pkg::readySet_} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*$define${QF::QF-base::intLock_} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QF::QF-base::intLock_} .................................................*/
uint_fast8_t volatile QF_intLock_;
/*$enddef${QF::QF-base::intLock_} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*$define${QF::QF-base::intNest_} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QF::QF-base::intNest_} .................................................*/
uint_fast8_t volatile QF_intNest_;
/*$enddef${QF::QF-base::intNest_} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*$define${QF::QF-pkg::readySet_rmc_} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QF::QF-pkg::readySet_rmc_} .............................................*/
#ifndef QP_NSSM
QPSet QF_readySet_rmc_;
#endif /* ndef QP_NSSM */
/*$enddef${QF::QF-pkg::readySet_rmc_} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 
//============================================================================
/*$define${QF::QF-pkg::bzero} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QF::QF-pkg::bzero} .....................................................*/
/*! @static @public @memberof QF */
void QF_bzero(
    void * const start,
    uint_fast16_t const len)
{
    uint8_t *ptr = (uint8_t *)start;
    for (uint_fast16_t n = len; n > 0U; --n) {
        *ptr = 0U;
        ++ptr;
    }
}
/*$enddef${QF::QF-pkg::bzero} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 
//============================================================================
/*$define${QF::QActive::ctor} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QF::QActive::ctor} .....................................................*/
/*! @protected @memberof QActive */
void QActive_ctor(QActive * const me,
    QStateHandler const initial)
{
    static QActiveVtable const vtable = { /* QActive virtual table */
        { &QHsm_init_,
          &QHsm_dispatch_
    #ifdef Q_SPY
          ,&QHsm_getStateHandler_
    #endif
        },
        &QActive_start_,
        &QActive_post_,
        &QActive_postLIFO_
    };
    /* clear the whole QActive object, so that the framework can start
    * correctly even if the startup code fails to clear the uninitialized
    * data (as is required by the C Standard).
    */
    QF_bzero(me, sizeof(*me));
 
    QHsm_ctor(&me->super, initial); /* explicitly call superclass' ctor */
    me->super.vptr = &vtable.super; /* hook the vptr to QActive vtable */
}
/*$enddef${QF::QActive::ctor} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*$define${QF::QActive::register_} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QF::QActive::register_} ................................................*/
/*! @protected @memberof QActive */
void QActive_register_(QActive * const me) {
    if (me->pthre == 0U) { /* preemption-threshold not defined? */
        me->pthre = me->prio; /* apply the default */
    }
 
    #ifndef QP_NSSM
 
    Q_REQUIRE_ID(100, (0U < me->prio) && (me->prio <= QF_MAX_ACTIVE)
                      && (QActive_registry_[me->prio] == (QActive *)0)
                      && (me->prio <= me->pthre));
 
    uint8_t prev_thre = me->pthre;
    uint8_t next_thre = me->pthre;
    uint_fast8_t p;
 
    for (p = (uint_fast8_t)me->prio - 1U; p > 0U; --p) {
        if (QActive_registry_[p] != (QActive *)0) {
            prev_thre = QActive_registry_[p]->pthre;
            break;
        }
    }
    for (p = (uint_fast8_t)me->prio + 1U; p <= QF_MAX_ACTIVE; ++p) {
        if (QActive_registry_[p] != (QActive *)0) {
            next_thre = QActive_registry_[p]->pthre;
            break;
        }
    }
 
    Q_ENSURE_ID(190, (prev_thre <= me->pthre) && (me->pthre <= next_thre));
 
    #endif /* QP_NSSM */
 
    QF_CRIT_STAT_
    QF_CRIT_E_();
    /* register the AO at the "QF-priority" */
    QActive_registry_[me->prio] = me;
    QF_CRIT_X_();
}
/*$enddef${QF::QActive::register_} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
/*$define${QF::QActive::unregister_} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QF::QActive::unregister_} ..............................................*/
/*! @protected @memberof QActive */
void QActive_unregister_(QActive * const me) {
    uint_fast8_t const p = (uint_fast8_t)me->prio;
 
    Q_REQUIRE_ID(200, (0U < p) && (p <= QF_MAX_ACTIVE)
                       && (QActive_registry_[p] == me));
    QF_CRIT_STAT_
    QF_CRIT_E_();
    QActive_registry_[p] = (QActive *)0; /* free-up the priority level */
    me->super.state.fun = Q_STATE_CAST(0); /* invalidate the state */
    QF_CRIT_X_();
}
/*$enddef${QF::QActive::unregister_} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/
 
//============================================================================
/*$define${QF-types::QF_LOG2} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv*/
 
/*${QF-types::QF_LOG2} .....................................................*/
#ifndef QF_LOG2
uint_fast8_t QF_LOG2(QPSetBits x) {
    static uint8_t const log2LUT[16] = {
        0U, 1U, 2U, 2U, 3U, 3U, 3U, 3U,
        4U, 4U, 4U, 4U, 4U, 4U, 4U, 4U
    };
    uint_fast8_t n = 0U;
    QPSetBits t;
 
    #if (QF_MAX_ACTIVE > 16U)
    t = (QPSetBits)(x >> 16U);
    if (t != 0U) {
        n += 16U;
        x = t;
    }
    #endif
    #if (QF_MAX_ACTIVE > 8U)
    t = (x >> 8U);
    if (t != 0U) {
        n += 8U;
        x = t;
    }
    #endif
    t = (x >> 4U);
    if (t != 0U) {
        n += 4U;
        x = t;
    }
    return n + log2LUT[x];
}
#endif /* ndef QF_LOG2 */
/*$enddef${QF-types::QF_LOG2} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/