FSM/vscode/FSM_OOP/baseFSM/FSM.c

/**
 * @file FSM.c
 * @author 天神 (dalaoshi@stu.xjtu.edu.cn)
 * @brief 
 * @version 2.1
 * @date 2024-05-07
 * 
 * @copyright 天神创意无限公司 2024
 * 
 */

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <string.h>

#include "FSM_private.h"
#include "FSM_protected.h"
#include "FSM_public.h"


/* -------------------------------------------------------------------------- */
/*                                private函数                                 */
/* -------------------------------------------------------------------------- */
/**
 * @brief 设置下一个状态，里面的子状态机暂时没用到
 * 
 * @param pFSM 状态机变量的基类指针
 */
static inline void updateNextState(FSM* pFSM){
    int curState = getCurState(pFSM);

    
    int nextState = doSelectNextState(pFSM, curState);
    setNextState(pFSM, nextState); 
    updateIndex(pFSM);
}

/**
 * @brief 递归退出整个状态机包括其子状态机，执行exit函数
 * 
 * @param pFSM 状态机变量的基类指针
 */
static void shutFSM(FSM *pFSM)
{
    int curState = getCurState(pFSM);
    if(hasChildFSM(pFSM, curState)){
        shutFSM(getChildFSM(pFSM, curState));
    }
    doExit(pFSM);
    setCurState(pFSM, FSM_Idle);
}



/**
 * @brief 
 * @deprecated 去掉了所有和预装载器相关的内容
 * @param pFSM 
 */
static inline void preload(FSM* pFSM){
    if(pFSM->privateVars->preloader.isReady){
        memcpy(pFSM->data, pFSM->privateVars->preloader.shadowData, pFSM->privateVars->preloader.size);
        pFSM->privateVars->preloader.isReady = 0;
    }    
}

/* -------------------------------------------------------------------------- */
/*                                  protected                                 */
/* -------------------------------------------------------------------------- */

/**
 * @brief 运行状态机，状态机框架的核心函数
 * @details 共分为三部首先判断是否有状态机切换，
 * @param pFSM 状态机基类指针
 */
void stepBaseFSM(FSM *pFSM)
{
    pFSM->pureVtbl.loadExternalData(pFSM->data);
    // preload(pFSM);
    updateNextState(pFSM);
    doResetSignals(pFSM);
    
    int curState = getCurState(pFSM);
    int index = getIndex(pFSM);
    int nextState = getNextState(pFSM);
    
    if(nextState && curState != nextState){  // 状态切换
        // 退出子状态机
        if(hasChildFSM(pFSM, curState)){
            FSM *cFSM = getChildFSM(pFSM, curState);
            shutFSM(cFSM);
        }

        doExit(pFSM);
        
        doTransition(pFSM);       // 有特定的状态转移函数
        doGeneralTransition(pFSM);      // 通用状态转移函数 

        doEnter(pFSM, nextState);

        // 进子状态机，必须从默认状态开始
        if(hasChildFSM(pFSM, nextState)){
            FSM *cFSM = getChildFSM(pFSM, nextState);
            Step(cFSM);
        }
        setCurState(pFSM, nextState);
    }
    else    // 状态机没动
    {
        if(!hasChildFSM(pFSM, curState)){
            doDuring(pFSM);
        }
        else{
            FSM *cFSM = getChildFSM(pFSM, curState);
            Step(cFSM);
        }
    }
}




/* -------------------------------------------------------------------------- */
/*                                public 函数                                 */
/* -------------------------------------------------------------------------- */
void _stepFSM(FSM *pFSM){
    pFSM->publicFcns.step(pFSM);
}

const char * _curState2ASCII(FSM *pFSM){
    return pFSM->publicFcns.curState2ASCII(pFSM);
}

inline int getFSMCurState(FSM *pFSM){
    return pFSM->privateVars->curState;
}
inline int getFSMNextState(FSM *pFSM){
    return pFSM->privateVars->nextState;
}




void registerChildFSM(FSM *parent, FSM *child, int state){
    parent->privateVars->childFSMTable[state] = child;
}



const void *_getData(FSM* pFSM){
    return (const void *)pFSM->data;
}

void _setSignal(FSM *pFSM, Uint16 signalFlag){
    pFSM->signals.all |= (1 << signalFlag);
}


/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 * @return void* 
 */
void *_preloadIn(FSM *pFSM){
    return pFSM->privateVars->preloader.shadowData;
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 */
void _preloaderGetReady(FSM *pFSM){
    if(pFSM->privateVars->preloader.isReady){
        pFSM->privateVars->preloader.isOverflow = 1;
    }
    pFSM->privateVars->preloader.isReady = 1;
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 * @return int 
 */
int _getPreloaderOverFlag(FSM *pFSM){
    return pFSM->privateVars->preloader.isOverflow;
}

/**
 * @brief 
 * @deprecated 弃用
 * @param pFSM 
 */
void _clearPreloaderOverFlag(FSM *pFSM){
    pFSM->privateVars->preloader.isOverflow = 0;
}




/* -------------------------------------------------------------------------- */
/*                   构造函数，分两段，先新建再赋值                            */
/* -------------------------------------------------------------------------- */
FSM*  newBaseFSM(int numState){
    typedef void (*StateFuncPtr)(void *); 
    typedef void (*ChildFSMStepFuncPtr)(FSM **); 
    typedef int (*TransitionFuncPtr)(void *, int *);
    typedef int (*SelectNextStateFcnPtr)(void *, FSMSignals *);

    FSM *pFSM = calloc(1, sizeof(FSM));
    pFSM->privateVars = newFMSPrivateVars(numState);

    FSMPureVtbl pureVtbl = {
        .setupHandler = NULL,
        .initData = NULL,
        .loadExternalData = NULL,
        .initDataLoader = NULL,
        .initSignals = NULL,
        .resetSignals = NULL,
    };
    pFSM->pureVtbl = pureVtbl;

    pFSM->publicFcns.step = stepBaseFSM;

    return pFSM;
}


void constructFSM(FSM* pFSM){
    assert(pFSM->pureVtbl.setupHandler);
    assert(pFSM->pureVtbl.initData);
    assert(pFSM->pureVtbl.initDataLoader);



    pFSM->pureVtbl.setupHandler(&pFSM->privateVars->fcns);
    pFSM->pureVtbl.initData(pFSM);
    pFSM->pureVtbl.initDataLoader(pFSM);

    /* ---------------------------------- 检查状态表 --------------------------------- */
    for (int i = 1; i < pFSM->privateVars->numState; i++) // 跳过Idle状态，Idle状态只能跳转到默认状态
    {
        if(!pFSM->privateVars->fcns.selectNextState[i]){
            FSM_LOG("每个状态都要有一个状态选择函数!\n");
            assert(0); // 强制退出
        }
    }
}