自学教程：C++ utFree函数代码示例

static void  sf_opaque_terminate_c2_ARP_02_RPSsmile_GloveAtomicBradNotImitateSmile(void  *chartInstanceVar){  if (chartInstanceVar!=NULL) {    SimStruct *S =      ((SFc2_ARP_02_RPSsmile_GloveAtomicBradNotImitateSmileInstanceStruct*)       chartInstanceVar)->S;    ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S));    if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {      sf_clear_rtw_identifier(S);      unload_ARP_02_RPSsmile_GloveAtomicBradNotImitateSmile_optimization_info();    }    finalize_c2_ARP_02_RPSsmile_GloveAtomicBradNotImitateSmile      ((SFc2_ARP_02_RPSsmile_GloveAtomicBradNotImitateSmileInstanceStruct*)       chartInstanceVar);    utFree((void *)chartInstanceVar);    if (crtInfo != NULL) {      utFree((void *)crtInfo);    }    ssSetUserData(S,NULL);  }}

/** Function: rtwCAPI_UpdateFullPaths =========================================* * */const char_T* rtwCAPI_UpdateFullPaths(rtwCAPI_ModelMappingInfo* mmi,                                      const char_T* path,                                      boolean_T isCalledFromTopModel){    int_T         i;    int_T         nCMMI;    size_t        pathLen;    char_T*       mmiPath;    size_t        mmiPathLen;    char_T*       relMMIPath;    size_t        relMMIPathLen;    if (mmi == NULL) return NULL;    utAssert(path != NULL);    utAssert( rtwCAPI_GetFullPath(mmi) == NULL );    pathLen = strlen(path)+1;    if (isCalledFromTopModel) {        /* If called from top model - FullPath is same as path */        mmiPath = (char_T*)utMalloc(pathLen*sizeof(char_T));        (void)memcpy(mmiPath, path, pathLen*sizeof(char_T));    }    else {                relMMIPath = rtwCAPI_EncodePath(rtwCAPI_GetPath(mmi));        if ( (relMMIPath== NULL) && (rtwCAPI_GetPath(mmi) != NULL)) {            return rtwCAPI_mallocError;        }        relMMIPathLen = relMMIPath ? (strlen(relMMIPath) + 1) : 0;                mmiPathLen = pathLen + relMMIPathLen;                mmiPath = (char_T*)utMalloc(mmiPathLen*sizeof(char_T));        if (mmiPath == NULL) return rtwCAPI_mallocError;        (void)memcpy(mmiPath, path, pathLen*sizeof(char_T));        utAssert(mmiPath[pathLen-1] == '/0');                if (relMMIPath) {            /* mmiPath = path + | + relMMIPath + '/0' */            mmiPath[pathLen-1] = '|';            (void)memcpy(&(mmiPath[pathLen]),                         relMMIPath, relMMIPathLen*sizeof(char_T));            utAssert(mmiPath[mmiPathLen-1] == '/0');            utFree(relMMIPath);        }    }    rtwCAPI_SetFullPath(*mmi, mmiPath);    nCMMI = rtwCAPI_GetChildMMIArrayLen(mmi);    for (i = 0; i < nCMMI; ++i) {        rtwCAPI_ModelMappingInfo* cMMI = rtwCAPI_GetChildMMI(mmi,i);        const char_T* errstr = rtwCAPI_UpdateFullPaths(cMMI, mmiPath, 0);        if (errstr != NULL) return errstr;    }    return NULL;} /* rtwCAPI_UpdateFullPaths */

static void sf_opaque_terminate_c6_CSE1_DP(void *chartInstanceVar){  if (chartInstanceVar!=NULL) {    SimStruct *S = ((SFc6_CSE1_DPInstanceStruct*) chartInstanceVar)->S;    ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S));    if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {      sf_clear_rtw_identifier(S);      unload_CSE1_DP_optimization_info();    }    finalize_c6_CSE1_DP((SFc6_CSE1_DPInstanceStruct*) chartInstanceVar);    utFree((void *)chartInstanceVar);    if (crtInfo != NULL) {      utFree((void *)crtInfo);    }    ssSetUserData(S,NULL);  }}

static void sf_opaque_terminate_c1_Engine_Vehicle_CVT_RS_System2(void  *chartInstanceVar){  if (chartInstanceVar!=NULL) {    SimStruct *S = ((SFc1_Engine_Vehicle_CVT_RS_System2InstanceStruct*)                    chartInstanceVar)->S;    ChartRunTimeInfo * crtInfo = (ChartRunTimeInfo *)(ssGetUserData(S));    if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {      sf_clear_rtw_identifier(S);      unload_Engine_Vehicle_CVT_RS_System2_optimization_info();    }    finalize_c1_Engine_Vehicle_CVT_RS_System2      ((SFc1_Engine_Vehicle_CVT_RS_System2InstanceStruct*) chartInstanceVar);    utFree(chartInstanceVar);    if (crtInfo != NULL) {      utFree(crtInfo);    }    ssSetUserData(S,NULL);  }}

static void sf_opaque_terminate_c1_main(void *chartInstanceVar){  if (chartInstanceVar!=NULL) {    SimStruct *S = ((SFc1_mainInstanceStruct*) chartInstanceVar)->S;    if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {      sf_clear_rtw_identifier(S);      unload_main_optimization_info();    }    finalize_c1_main((SFc1_mainInstanceStruct*) chartInstanceVar);    utFree((void *)chartInstanceVar);    ssSetUserData(S,NULL);  }}

static void sf_opaque_terminate_c4_MigrationBGOW_Proto6_MultiSwarm(void  *chartInstanceVar){  if (chartInstanceVar!=NULL) {    SimStruct *S = ((SFc4_MigrationBGOW_Proto6_MultiSwarmInstanceStruct*)                    chartInstanceVar)->S;    if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {      sf_clear_rtw_identifier(S);      unload_MigrationBGOW_Proto6_MultiSwarm_optimization_info();    }    finalize_c4_MigrationBGOW_Proto6_MultiSwarm      ((SFc4_MigrationBGOW_Proto6_MultiSwarmInstanceStruct*) chartInstanceVar);    utFree((void *)chartInstanceVar);    ssSetUserData(S,NULL);  }}

/** Function: rtwCAPI_GetFullStateBlockPath =================================== * */char* rtwCAPI_GetFullStateBlockPath(const char* stateBlockPath,                                           const char* mmiPath,                                           size_t      mmiPathLen,                                           boolean_T   crossingModel){    char_T* blockPath          = NULL;    char_T* fullStateBlockPath = NULL;    size_t     fullStateBlockPathLen;    if (stateBlockPath == NULL) goto EXIT_POINT;    /* fullStateBlockPath = mmiPath + | + blockPath + '/0' */    /* If crossing a model boundary encode, otherwise do not */    if (crossingModel) {        blockPath = rtwCAPI_EncodePath(stateBlockPath);        if (blockPath == NULL) goto EXIT_POINT;    } else {        size_t len = strlen(stateBlockPath)+1;        blockPath = (char*)utMalloc(len*sizeof(char));        if (blockPath == NULL) goto EXIT_POINT;        (void)strcpy(blockPath,stateBlockPath);    }    utAssert(blockPath != NULL);    fullStateBlockPathLen = ( (mmiPath==NULL) ?                              strlen(blockPath) + 1 :                              mmiPathLen + strlen(blockPath) + 2 );    fullStateBlockPath    = (char*)utMalloc(fullStateBlockPathLen*sizeof(char));    if (fullStateBlockPath == NULL) goto EXIT_POINT;    if (mmiPath != NULL) {        (void)strcpy(fullStateBlockPath, mmiPath);        fullStateBlockPath[mmiPathLen]   = '|';        fullStateBlockPath[mmiPathLen+1] =  '/0';        (void)strcat(fullStateBlockPath, blockPath);    } else {        (void)strcpy(fullStateBlockPath, blockPath);        fullStateBlockPath[fullStateBlockPathLen-1] =  '/0';    }    utAssert(fullStateBlockPath[fullStateBlockPathLen-1] == '/0');  EXIT_POINT:    utFree(blockPath);    return fullStateBlockPath; /* caller is responsible for free */}

static void sf_opaque_terminate_c1_VrSubsystem(void *chartInstanceVar){  if (chartInstanceVar!=NULL) {    SimStruct *S = ((SFc1_VrSubsystemInstanceStruct*) chartInstanceVar)->S;    if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {      sf_clear_rtw_identifier(S);      unload_VrSubsystem_optimization_info();    }    finalize_c1_VrSubsystem((SFc1_VrSubsystemInstanceStruct*) chartInstanceVar);    utFree(chartInstanceVar);    if (ssGetUserData(S)!= NULL) {      sf_free_ChartRunTimeInfo(S);    }    ssSetUserData(S,NULL);  }}

static void sf_opaque_terminate_c2_MigrationOWBG_Proto4_1DLinear2DNonLinear(void  *chartInstanceVar){  if (chartInstanceVar!=NULL) {    SimStruct *S = ((SFc2_MigrationOWBG_Proto4_1DLinear2DNonLinearInstanceStruct*)                    chartInstanceVar)->S;    if (sim_mode_is_rtw_gen(S) || sim_mode_is_external(S)) {      sf_clear_rtw_identifier(S);      unload_MigrationOWBG_Proto4_1DLinear2DNonLinear_optimization_info();    }    finalize_c2_MigrationOWBG_Proto4_1DLinear2DNonLinear      ((SFc2_MigrationOWBG_Proto4_1DLinear2DNonLinearInstanceStruct*)       chartInstanceVar);    utFree((void *)chartInstanceVar);    ssSetUserData(S,NULL);  }}

/** Function: rtwCAPI_FreeFullPaths ============================================ * */void rtwCAPI_FreeFullPaths(rtwCAPI_ModelMappingInfo* mmi){    int_T   i;    int_T   nCMMI;    char_T* fullPath;    if (mmi == NULL) return;    fullPath = rtwCAPI_GetFullPath(mmi);    utAssert(fullPath != NULL);    utFree(fullPath);    rtwCAPI_SetFullPath(*mmi, NULL);    nCMMI = rtwCAPI_GetChildMMIArrayLen(mmi);    for (i = 0; i < nCMMI; ++i) {        rtwCAPI_ModelMappingInfo* cMMI = rtwCAPI_GetChildMMI(mmi,i);        rtwCAPI_FreeFullPaths(cMMI);    }} /* rtwCAPI_FreeFullPaths */

boolean_T Deadbeat_CUK_acc_rt_TDelayUpdateTailOrGrowBuf ( int_T * bufSzPtr ,int_T * tailPtr , int_T * headPtr , int_T * lastPtr , real_T tMinusDelay ,real_T * * tBufPtr , real_T * * uBufPtr , real_T * * xBufPtr , boolean_Tisfixedbuf , boolean_T istransportdelay , int_T * maxNewBufSzPtr ) { int_TtestIdx ; int_T tail = * tailPtr ; int_T bufSz = * bufSzPtr ; real_T * tBuf =* tBufPtr ; real_T * xBuf = ( NULL ) ; int_T numBuffer = 2 ; if (istransportdelay ) { numBuffer = 3 ; xBuf = * xBufPtr ; } testIdx = ( tail <( bufSz - 1 ) ) ? ( tail + 1 ) : 0 ; if ( ( tMinusDelay <= tBuf [ testIdx ] )&& ! isfixedbuf ) { int_T j ; real_T * tempT ; real_T * tempU ; real_T *tempX = ( NULL ) ; real_T * uBuf = * uBufPtr ; int_T newBufSz = bufSz + 1024; if ( newBufSz > * maxNewBufSzPtr ) { * maxNewBufSzPtr = newBufSz ; } tempU= ( real_T * ) utMalloc ( numBuffer * newBufSz * sizeof ( real_T ) ) ; if (tempU == ( NULL ) ) { return ( false ) ; } tempT = tempU + newBufSz ; if (istransportdelay ) tempX = tempT + newBufSz ; for ( j = tail ; j < bufSz ; j++ ) { tempT [ j - tail ] = tBuf [ j ] ; tempU [ j - tail ] = uBuf [ j ] ; if( istransportdelay ) tempX [ j - tail ] = xBuf [ j ] ; } for ( j = 0 ; j <tail ; j ++ ) { tempT [ j + bufSz - tail ] = tBuf [ j ] ; tempU [ j + bufSz -tail ] = uBuf [ j ] ; if ( istransportdelay ) tempX [ j + bufSz - tail ] =xBuf [ j ] ; } if ( * lastPtr > tail ) { * lastPtr -= tail ; } else { *lastPtr += ( bufSz - tail ) ; } * tailPtr = 0 ; * headPtr = bufSz ; utFree (uBuf ) ; * bufSzPtr = newBufSz ; * tBufPtr = tempT ; * uBufPtr = tempU ; if (istransportdelay ) * xBufPtr = tempX ; } else { * tailPtr = testIdx ; }return ( true ) ; } real_T Deadbeat_CUK_acc_rt_TDelayInterpolate ( real_T

void rt_CleanUpForStateLogWithMMI(RTWLogInfo *li){    int_T i;    RTWLogSignalInfo *sigInfo = _rtliGetLogXSignalInfo(li); /* get the non-const ptr */    int_T nSignals = sigInfo->numSignals;    if ( nSignals > 0 ) {        for (i = 0; i < nSignals; ++i) utFree(sigInfo->blockNames.ptr[i]);        FREE(sigInfo->blockNames.ptr);        FREE(sigInfo->labels.ptr);        FREE(sigInfo->crossMdlRef);        FREE(sigInfo->dims);        FREE(sigInfo->dataTypes);        FREE(sigInfo->complexSignals);        FREE(sigInfo->isVarDims);        FREE(sigInfo);        rtliSetLogXSignalInfo(li, NULL);        FREE(_rtliGetLogXSignalPtrs(li)); /* get the non-const ptr */        rtliSetLogXSignalPtrs(li,NULL);    }}

//.........这里部分代码省略.........    /* reset error status */    *errStatus = NULL;    sigInfo = (RTWLogSignalInfo *)calloc(1,sizeof(RTWLogSignalInfo));    if (sigInfo == NULL) goto ERROR_EXIT;    nSignals = rtwCAPI_GetNumStateRecordsForRTWLogging(mmi);    if (nSignals >0) {        /* These are all freed before exiting this function */        dims        = (int_T *)calloc(nSignals,sizeof(int_T));        if (dims == NULL) goto ERROR_EXIT;        dTypes      = (BuiltInDTypeId *)calloc(nSignals,sizeof(BuiltInDTypeId));        if (dTypes == NULL) goto ERROR_EXIT;        cSgnls      = (int_T *)calloc(nSignals,sizeof(int_T));        if (cSgnls == NULL) goto ERROR_EXIT;        labels      = (char_T **)calloc(nSignals, sizeof(char_T*));        if (labels == NULL) goto ERROR_EXIT;        blockNames  = (char_T**)calloc(nSignals, sizeof(char_T*));        if (blockNames == NULL) goto ERROR_EXIT;        stateNames  = (char_T**)calloc(nSignals, sizeof(char_T*));        if (stateNames == NULL) goto ERROR_EXIT;        crossMdlRef  = (boolean_T*)calloc(nSignals, sizeof(boolean_T));        if (crossMdlRef == NULL) goto ERROR_EXIT;        logDataType = (int_T *)calloc(nSignals,sizeof(int_T));        if (logDataType == NULL) goto ERROR_EXIT;        /* Allocate memeory for isVarDims pointer and set all elements to 0's */        isVarDims = (boolean_T *)calloc(nSignals,sizeof(boolean_T));        if (isVarDims == NULL) goto ERROR_EXIT;        /* This is freed in stopDataLogging (it's needed in the meantime) */        sigDataAddr = (void **)calloc(nSignals,sizeof(void *));        if (sigDataAddr == NULL) goto ERROR_EXIT;        *errStatus = rtwCAPI_GetStateRecordInfo(mmi,                                                (const char_T**) blockNames,                                                (const char_T**) labels,                                                (const char_T**) stateNames,                                                dims,                                                (int_T*)dTypes,                                                logDataType,                                                cSgnls,                                                sigDataAddr,                                                crossMdlRef,                                                NULL,                                                NULL, /* sigSampleTime */                                                &sigIdx,                                                false, /* crossingModel */                                                NULL,  /* stateDerivVector */                                                ACCESS_C_API_FOR_RTW_LOGGING);        if (*errStatus != NULL) goto ERROR_EXIT;        rtliSetLogXSignalPtrs(li,(LogSignalPtrsType)sigDataAddr);    }    sigInfo->numSignals = nSignals;    sigInfo->numCols = dims;    sigInfo->numDims = NULL;    sigInfo->dims = dims;    sigInfo->dataTypes = dTypes;    sigInfo->complexSignals = cSgnls;    sigInfo->frameData = NULL;    sigInfo->labels.ptr = labels;    sigInfo->titles = NULL;    sigInfo->titleLengths = NULL;    sigInfo->plotStyles = NULL;    sigInfo->blockNames.ptr = blockNames;    sigInfo->stateNames.ptr = stateNames;    sigInfo->crossMdlRef = crossMdlRef;    sigInfo->dataTypeConvert = NULL;    sigInfo->isVarDims = isVarDims;    sigInfo->currSigDims = NULL;    rtliSetLogXSignalInfo(li,sigInfo);    /* Free logDataType it's not needed any more,     * the rest of them will be freed later */    FREE(logDataType);    return(NULL); /* NORMAL_EXIT */  ERROR_EXIT:    if (*errStatus == NULL) {        *errStatus = rtMemAllocError;    }    /* Free local stuff that was allocated. It is no longer needed */    for (i = 0; i < nSignals; ++i) utFree(blockNames[i]);    FREE(blockNames);    for (i = 0; i < nSignals; ++i) utFree(stateNames[i]);    FREE(stateNames);    FREE(labels);    FREE(dims);    FREE(dTypes);    FREE(logDataType);    FREE(cSgnls);    FREE(isVarDims);    return(*errStatus);} /* end rt_InitSignalsStruct */

//.........这里部分代码省略.........    for (i = 0; i < nSignals; ++i) {        uint_T mapIdx;        size_t sigPathLen;        char*  sigPath;        /* For RTW logging, skip states that cannot be logged to MAT-File. */        if ((rtwLogging) &&            (rtwCAPI_CanLogSignalToMATFile(dataTypeMap, signals, i) == false)) continue;        /* sigBlockPath = mmiPath + | + BlockPath + '/0' */        /* If crossing a model boundary encode, otherwise do not */        if (crossingModel) {            blockPath = rtwCAPI_EncodePath(rtwCAPI_GetSignalBlockPath(signals, i));            if ( (blockPath == NULL) &&                 (rtwCAPI_GetSignalBlockPath(signals, i) != NULL)) {                errstr = rtwCAPI_mallocError;                goto EXIT_POINT;            }        } else {            const char* constBlockPath = rtwCAPI_GetSignalBlockPath(signals, i);            blockPath = (char*)utMalloc((strlen(constBlockPath)+1)*sizeof(char));            (void)strcpy(blockPath, constBlockPath);        }        utAssert(blockPath != NULL);        sigPathLen = ( (mmiPath==NULL) ?                                   strlen(blockPath) + 1 :                                   mmiPathLen + strlen(blockPath) + 2 );        sigPath    = (char*)utMalloc(sigPathLen*sizeof(char));        if (sigPath == NULL) {            errstr = rtwCAPI_mallocError;            goto EXIT_POINT;        }        if (mmiPath != NULL) {            (void)strcpy(sigPath, mmiPath);            sigPath[mmiPathLen]   = '|';            sigPath[mmiPathLen+1] =  '/0';            (void)strcat(sigPath, blockPath);        } else {            (void)strcpy(sigPath, blockPath);            sigPath[sigPathLen-1] =  '/0';        }       /* need to free for every iteration of the loop, but also have        * the free below EXIT_POINT in case of error */        utFree(blockPath);        blockPath = NULL;        utAssert(sigPath[sigPathLen-1] == '/0');        sigBlockName[*sigIdx] = sigPath; /* caller is responsible for free */        /* Label */        sigLabel[*sigIdx] = rtwCAPI_GetSignalName(signals, i);        /* Width */        mapIdx = rtwCAPI_GetSignalDimensionIdx(signals, i);        utAssert( rtwCAPI_GetNumDims(dimMap,mapIdx) == 2 );        mapIdx = rtwCAPI_GetDimArrayIndex(dimMap, mapIdx);        sigWidth[*sigIdx] = dimArray[mapIdx] * dimArray[mapIdx+1];        /* DataType and logDataType */        mapIdx = rtwCAPI_GetSignalDataTypeIdx(signals, i);        sigDataType[*sigIdx] = rtwCAPI_GetDataTypeSLId(dataTypeMap, mapIdx);        /* this mimics code in simulink.dll:mapSigDataTypeToLogDataType */        if ( SS_DOUBLE ||             SS_SINGLE ||             SS_INT8   ||             SS_UINT8  ||             SS_INT16  ||             SS_UINT16 ||             SS_INT32  ||             SS_UINT32 ||             SS_BOOLEAN ) {            logDataType[*sigIdx] = sigDataType[*sigIdx];        } else {            logDataType[*sigIdx] = SS_DOUBLE;        }        /* Complexity */        sigComplexity[*sigIdx] = rtwCAPI_GetDataIsComplex(dataTypeMap, mapIdx);        /* Data Access - Pointer or Direct*/        isPointer = ((uint8_T)rtwCAPI_GetDataIsPointer(dataTypeMap, mapIdx));        /* Address */        mapIdx = rtwCAPI_GetSignalAddrIdx(signals, i);        rtwCAPI_GetSigAddrFromMap(isPointer, sigComplexity, sigDataType,                                  sigDataAddr, sigIdx, mapIdx, dataAddrMap);        /* CrossingModelBoundary */        sigCrossMdlRef[*sigIdx] = crossingModel;        ++(*sigIdx);    }  EXIT_POINT:    utFree(blockPath);    return(errstr);} /* rtwCAPI_GetSigLogRecordInfo */