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_T
isfixedbuf , boolean_T istransportdelay , int_T * maxNewBufSzPtr ) { int_T
testIdx ; 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);
}
}
/* Function: rt_FillStateSigInfoFromMMI =======================================
* Abstract:
*
* Returns:
* == NULL => success.
* ~= NULL => failure, the return value is a pointer to the error
* message, which is also set in the simstruct.
*/
const char_T * rt_FillStateSigInfoFromMMI(RTWLogInfo *li,
const char_T **errStatus)
{
int_T i;
int_T nSignals = 0;
int_T *dims = NULL;
BuiltInDTypeId *dTypes = NULL;
int_T *cSgnls = NULL;
char_T **labels = NULL;
char_T **blockNames = NULL;
char_T **stateNames = NULL;
boolean_T *crossMdlRef = NULL;
void **sigDataAddr = NULL;
int_T *logDataType = NULL;
boolean_T *isVarDims = NULL;
const rtwCAPI_ModelMappingInfo *mmi = (const rtwCAPI_ModelMappingInfo *)rtliGetMMI(li);
int_T sigIdx = 0;
RTWLogSignalInfo * sigInfo;
/* 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 */
/** Function: rtwCAPI_GetSigLogRecordInfo ======================================
*
*/
const char_T* rtwCAPI_GetSigLogRecordInfo(const rtwCAPI_ModelMappingInfo* mmi,
const char_T** sigBlockName,
const char_T** sigLabel,
int_T* sigWidth,
int_T* sigDataType,
int_T* logDataType,
int_T* sigComplexity,
void** sigDataAddr,
boolean_T* sigCrossMdlRef,
int_T* sigIdx,
boolean_T crossingModel,
boolean_T rtwLogging)
{
int_T i;
int_T nCMMI;
int_T nSignals;
const char_T* mmiPath;
size_t mmiPathLen;
const rtwCAPI_Signals* signals;
const rtwCAPI_DimensionMap* dimMap;
const uint_T* dimArray;
const rtwCAPI_DataTypeMap* dataTypeMap;
void** dataAddrMap;
const char_T* errstr = NULL;
uint8_T isPointer = 0;
char* blockPath = NULL;
if (mmi == NULL) goto EXIT_POINT;
nCMMI = rtwCAPI_GetChildMMIArrayLen(mmi);
for (i = 0; i < nCMMI; ++i) {
rtwCAPI_ModelMappingInfo* cMMI = rtwCAPI_GetChildMMI(mmi,i);
errstr = rtwCAPI_GetSigLogRecordInfo(cMMI,
sigBlockName,
sigLabel,
sigWidth,
sigDataType,
logDataType,
sigComplexity,
sigDataAddr,
sigCrossMdlRef,
sigIdx,
true,
rtwLogging);
if (errstr != NULL) goto EXIT_POINT;
}
nSignals = rtwCAPI_GetNumSignals(mmi);
if (nSignals < 1) goto EXIT_POINT;
mmiPath = rtwCAPI_GetFullPath(mmi);
mmiPathLen = (mmiPath==NULL)? 0 : strlen(mmiPath);
signals = rtwCAPI_GetSignals(mmi);
dimMap = rtwCAPI_GetDimensionMap(mmi);
dimArray = rtwCAPI_GetDimensionArray(mmi);
dataTypeMap = rtwCAPI_GetDataTypeMap(mmi);
dataAddrMap = rtwCAPI_GetDataAddressMap(mmi);
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 */
