%selectfile NULL_FILE
%%
%%
%%
%%Copyright1994-2020TheMathWorks,Inc.
%%
%%Disclaimer
%%==========
%%
%%ThefunctionalityprovidedinthisTLCmoduleiscurrentlyunder
%%development.MathWorksreservestherighttomakechanges
%%withoutnotice.
%%
%%Thislibraryisoptimizedforspeed,andthereforedoesnotusethe
%%formalTLCaccessfunctions.Thismeansthatthecodemaynotbe
%%backwardcompatiblewithfuturereleases.Hence,youshouldnot
%%mimictheprogramingstyleorlogicfoundinthislibraryfile.
%%
%%
%%DeviationsfromR13Map
%%=======================
%%
%%oContinuousstates-Bydefault,MapContinuousstates&StateDerivatives
%%oSimulinkBus-Supportnon-virtualSimulinkBusstructures.
%%IMPORTANT:AddedIsStructtoDatarecord.CodepriortoR14must
%%beupdatedtohandletheIsStructfieldproperly.Otherwise,
%%non-virtualbuseswillbemisinterpreted.
%%oMemoryenhancements
%%-UsingDataDefaults(defaultsforvariables)
%%-FixedPoint-ReferencedRecordsforstoringFixedPointinformation
%%oParameterValue-Valuefieldforparameterrecords
%%oCustomDataAccess-AddedAccessfieldforCustomData.Datarecords.
%%MapsDataAccessvalueprovidedintheCustomStorage
%%Classdefinition.
%%(Access="direct":DataAccess="Direct"
%%="indirect":DataAccess="Pointer"
%%="unknown":dataaccessnotdefinedin
%%Customclassdefinition
%%oData.Classbugfix-The"Class"fieldforvectordataisupdated
%%InR13,
%%Forrowandcolumnvectors:Class="col-mat"
%%
%%InR14,
%%Forrowandcolumnvectors:Class="vector"
%%
%%
%%DeviationsfromR12Map
%%=======================
%%
%%oDWorkchanges:
%%-Bydefault,mapdwork
%%-Supportnonstructureddworkdata
%%oSupportCustomStorageclasses
%%
%%DeviationsfromR11Map
%%=======================
%%
%%oDWorkchanges:
%%-::CompiledModel.DWorkRecords.DWorkRecordchangedto
%%::CompiledModel.DWorks.DWork
%%-RWork,IWork,PWorkandModesarenowpartofDWork
%%oMethodofinitiatingmapgeneration
%%-%assignGenerateInterfaceAPI=1(SeeNote11)
%%-Notalldataismappedbydefault(SeeLibMapData)
%%oMemoryMapIdxisaddedtoeachModelParameterand
%%Block.Parameterreferenceunconditionally
%%oSimulinkGlobalstorageclassissynonomouswithAuto
%%oAddedmatrixsupport,includingN-Dmatrix
%%oAddedofObjectPropertiessupport(SeeNote10)
%%oStateflowworkspacedataremoved
%%oNearlyallmatricesareincolumnmajororderversus
%%rowmajororder
%%
%%Abstract
%%========
%%
%%Therearecurrentlysixdatastructuresthatcontainvariablesofmixed
%%datatypeandcomplexity.
%%
%%oBlockI/O
%%oConstantBlockI/O
%%oParameters
%%oDWork
%%oExternalInputs
%%oExternalOutputs
%%
%%Additionally,signals,parameters,anddworkcanhaveexternalstorage
%%classdeclarationsmakingthemunstructuredglobalvariables.
%%
%%Thegoalofthisspecificationistopresentaconsistentviewof
%%signals,statesandparameterssothatyoucaneasilyand
%%consistentlyinterfacememorydeclaredbySimulinkCoder.
%%
%%TheideaistocreateaTLCrecordwhichcontainsallinformation
%%requiredforaccessingmemoryinthegeneratedcode.
%%
%%Signals(BlockI/O)
%%===================
%%
%%Assumeanon-complexsignalfoowithwidth3.AMemoryMapIdxfield
%%isadded(atTLCruntime)totheBlockOutputrecord.
%%
%%BlockOutputs{
%%NumGlobalBlockOutputs10
%%GlobalBlockOutput{
%%Identifierfoo
%%MemoryMapIdx[0,0,0]<---Addedduringmapprocess
%%}
%%}
%%
%%TheMemoryMapIdxfieldpointsintoaglobaldatamaprecord.The
%%valuespecifieswhichdatatoaccessinsidetheGlobalMemoryMap
%%record.
%%
%%TheMemoryMapIdxisalwayspresent,andisinterpretedasfollows.
%%
%%[structureIdx,sectionIdx,dataIdx]--Globalstructureddata
%%[-1,classIdx,dataIdx]--Customdata
%%[-1,-1,dataIdx]--Globalunstructureddata
%%[-1,-1,-1]--Localorreuseddata
%%
%%%assigngmm=GlobalMemoryMap
%%%ifMemoryMapIdx[2]==-1
%%%%dataisunavailable(probablylocalorreused)
%%%elseifMemoryMapIdx[1]==-1
%%%%globalunstructureddata
%%%assigndataIdx=MemoryMapIdx[2]
%%%assigndata=gmm.UnstructuredData.Data[dataIdx]
%%%elseifMemoryMapIdx[0]==-1
%%%%customdata
%%%assignclassIdx=MemoryMapIdx[1]
%%%assigndataIdx=MemoryMapIdx[2]
%%%assigndata=gmm.CustomData[classIdx].Data[dataIdx]
%%%else
%%%%globalstructureddata
%%%assignstructureIdx=MemoryMapIdx[0]
%%%assignsectionIdx=MemoryMapIdx[1]
%%%assigndataIdx=MemoryMapIdx[2]
%%%assigndata=...
%%gmm.StructuredData[structureIdx].Section[sectionIdx].Data[dataIdx]
%%%endif
%%
%%Theglobalmemorymapisacollectionofstructured,custom,and
%%unstructureddatasections.Sectionsareglobsofmemorythathave
%%"likeness",andtheycanbestructuredorunstructured.Whensectionsof
%%memoryarecontainedwithinaC-structuretheyareStructuredData.
%%Otherwise,aCustomDataorUnstructuredDatasectionisacollectionof
%%unstructuredC-variables.
%%
%%Parameters
%%==========
%%
%%Thereisaglobalsettingforinliningparameters.Bydefault,inline
%%parametersisoffwhichmeansthateachblockparameterinthemodelis
%%tunable.Inthiscase,aparameterisreferencedusinganabsoluteblock
%%pathnamealongwiththeblock'spaticularparametername.Itisalso
%%possibletotuneparametersbyMATLABvariablenamewheninlineparameters
%%isoff.Thisoftenleadstoa1-to-manymappingsituationforatunable
%%variable.Forexample,havinginlineparametersoffmeansthateveryblock
%%parametercanbeindependentlytuned.However,if100gainblocksspecify
%%theirparameteras"k"theneach"instanceofk"mustbeupdatedwhen"k"
%%istobemodifiedonamodel-widebasis.
%%
%%Wheninlineparametersison,likeblockparameterscollapsetoasingle
%%memorylocation(whenspecifiedastunableparameters).Thismeans
%%thatall100gainparametersinthepreviousexamplecollapsetoa
%%single"k"memorylocation.
%%
%%InlineParametersOff:
%%
%%AMemoryMapIdxisaddedtoeach::CompiledModel.System.Block.Parameter
%%record,andpointstoGlobalMemoryMapasfollows.
%%
%%[structureIdx,sectionIdx,dataIdx]--Globalstructureddata
%%[-1,-1,-1]--Notaccessible
%%
%%Additionally,theGlobalMemoryMapwillcontainalistoftunableMATLAB
%%variables.SincetunableMATLABvariablesaremodelbasedtheyare
%%addeddirectlytotheGlobalMemoryMap.
%%
%%GlobalMemoryMap{
%%ModelParameters{
%%NumModelParameters1
%%ModelParameter{
%%Name"k"
%%NumInstances2
%%Instance{
%%Source"SL"
%%Parent"root/sys1/block1"
%%MemoryMapIdx[structureIdx,sectionIdx,dataIdx]
%%}
%%Instance{
%%Source"SF"
%%Parent"machine"
%%MemoryMapIdx[-1,-1,dataIdx]
%%}
%%}
%%}
%%}
%%
%%TheMemoryMapIdxcanpointtobothstructuredandunstructureddata.
%%Simulinkblockparametersarestructureddata.Stateflowmachine
%%parentedimportedandexporteddataareunstructureddata.
%%
%%NotethatSimulinkparametersaresometimestransformed.Forexample,
%%maskinitializationcodemaytransformavariableusedbyablock
%%containedwithinthemask.Therefore,anadditionalIsTransformedfield
%%isaddedtoeachparameterintheGlobalMemoryMap.Hence,specialcare
%%mustbetakentotuneatransformedparameter(IsTransformed==1).
%%
%%InlineParametersOn:
%%
%%Parametersaretunedonamodelbasiswheninlineparametersis
%%selected.Allparameterinformationisattachedderectlyto
%%GlobalMemoryMapsimilartotheinlineparametersoffcaseexceptthat
%%SourceandParentaresetto"multiple"whenthesourcelocation
%%oftheparameterisnotunique.
%%
%%Thenumberofinstancesofaparametervariesdependingonthe
%%SimulinkparameterstorageclassandtheStateflowdatascope.For
%%example,NumInstances=1ifaSimulinkparameterkhasanImportedExtern
%%storageclassandaStateflowmachineparenteddatahasanexportedscope.
%%Inotherwords,SimulinkandStateflowmapktothesamepieceofmemory.
%%
%%However,SimulinkandStateflowdonotmaptothesamememorywhen
%%khasanAutostorageclassinSimulink(regardlessoftheStateflow
%%scope).SimulinkaccesseskasrtP.kandStateflowaccesseskask.
%%
%%ThefollowingtablesummarizesthecombinatoricsbetweenSimulink
%%parametersandStateflowdata.Anumbersignifiesthenumber
%%ofinstances(i.e.,thenumberofvariablescreated)"E"signifies
%%thatanerrorisgeneratedwhenencountered.
%%
%%SimulinkStorageClass
%%
%%SimulinkExportedImportedImported
%%GlobalGlobalExternExternPointer
%%======================================
%%StateflowScope
%%Imported21(b)1(b)E
%%Exported2E1(a)E
%%
%%(a)Recommended,anddoesnotrequireanyuserdefineddatadefinition
%%(b)Requiresuserdefineddatadefinition
%%
%%Anexamplemapfortheinlineparametersoncasefollows.
%%
%%GlobalMemoryMap{
%%ModelParameters{
%%NumModelParameters2
%%ModelParameter{
%%Name"k1"
%%NumInstances2
%%Instance{
%%Source"SL"
%%Parent"root/sys/block"
%%MemoryMapIdx[structureIdx,sectionIdx,dataIdx]
%%}
%%Instance{
%%Source"SF"
%%Parent"Machine"
%%MemoryMapIdx[-1,-1,dataIdx]
%%}
%%}
%%ModelParameter{
%%Name"k2"
%%NumInstances1
%%Instance{
%%Source"multiple"
%%Parent"multiple"
%%MemoryMapIdx[-1,-1,dataIdx]
%%}
%%}
%%}
%%}
%%
%%SimulinkStates
%%===============
%%ToBeDocumented
%%
%%ExternalInputs
%%===============
%%
%%Externalinputsarestructuredorunstructureddata.AMemoryMapIdxis
%%attachedtoeach::CompiledModel.ExternalInputs.ExternalInputrecordand
%%interpretedasfollows.
%%
%%[structureIdx,sectionIdx,dataIdx]--Globalstructureddata
%%[-1,-1,dataIdx]--Globalunstructureddata
%%
%%%ifMemoryMapIdx[1]==-1
%%%%globalunstructureddata
%%%else
%%%%globalstructureddata
%%%endif
%%
%%Externalinputsareverysimilartoblockoutputsexcepttheyarenever
%%local.
%%
%%ExternalOutputs
%%================
%%
%%Externaloutputsarealwaysstructureddata.AMemoryMapIdxisattached
%%toeach::CompiledModel.ExternalOutputs.ExternalOutputrecordandinterpreted
%%asfollows.
%%
%%[structureIdx,sectionIdx,dataIdx]--Globalstructureddata
%%
%%Notes
%%=====
%%
%%1.StructuredDatacontainsanOffsetFromBaseAddr.UnstructuredData
%%doesnot.
%%
%%2.StructuredDataisalwaysdirectmemoryaccess.UnstructuredData
%%canhavedirectorindirectmemoryaccess.
%%
%%3.StructuredDatasectionshavecommondatatype,complexity,
%%andmemoryaccess.Unstructureddatasectionslistthese
%%attributesseparatelywithineachdatarecord.
%%
%%4.Fixed-pointdataincludesanextraFixedPointInforecord(test
%%IsFixedPointtodetermineiftheadditionalrecordexists).Fixed-point
%%vectorandmatrixdatacanhaveuniformornon-uniformelementscaling.
%%Uniformfixed-pointdataisrepresentedwithasingle(flat)recordfor
%%allofitselements.
%%
%%FixedPointInfo{
%%Scaling"uniform"
%%NumBits16
%%NumRequiredBits16
%%IsSigned1
%%FixedExp-4
%%FracSlope1.0
%%Bias0.0
%%}
%%
%%Non-uniformfixed-pointdataisrepresentedwithadditionalElementScaling
%%records.Forexample,anon-uniform3elementvectorhas3ElementScaling
%%recordsforits3elements.
%%
%%FixedPointInfo{
%%Scaling"non-uniform"
%%NumBits16
%%NumRequiredBits16
%%IsSigned1
%%NumElementScalings3
%%ElementScaling{
%%FixedExp-4
%%FracSlope1.0
%%Bias12.0
%%}
%%ElementScaling{
%%FixedExp-5
%%FracSlope2.0
%%Bias40.0
%%}
%%ElementScaling{
%%FixedExp-6
%%FracSlope1.0
%%Bias90.0
%%}
%%}
%%
%%Elementsofanon-uniformMxNmatrixarelaidoutasfollows.
%%
%%Data(1,1)=ElementScaling[0]
%%Data(1,2)=ElementScaling[1]
%%Data(1,N)=ElementScaling[N-1]
%%Data(2,1)=ElementScaling[N]
%%etc.
%%
%%Thereal-worldvalueisderivedfromaquantizedintegerasfollows.
%%
%%Vreal=FracSlope*2^FixedExp*Qint+Bias
%%
%%TheDataTypeIdxforfixed-pointdatatypesissomewhatirrelevant.
%%MostlikelyyoushoulduseNumBitsinitsplace.Fixed-pointmatrices
%%arecurrently2-Dimensionalonly.
%%
%%NumBitsprovidesthenumberofbitsneededbytheintegertypeinwhich
%%thefixedpointdataisstored.NumRequiredBitsisthenumberofbits
%%actuallyrequiredforthefixedpointdatatoberepresentedinMATLAB.
%%Inmostcases,NumRequiredBitswillbeequaltoNumBits.However,for
%%odd-sizedfixedpointdatatypes,thefieldswillbedifferent.Fore.g:
%%InMATLAB,ifasignal'soutputdatatypeissfix(11),itwillbestored
%%asa16-bitintegerinthegeneratedcode.TheFixedPointInfowillbe
%%FixedPointInfo{
%%Scaling"uniform"
%%NumBits16
%%NumRequiredBits11
%%IsSigned1
%%FixedExp-4
%%FracSlope1.0
%%Bias0.0
%%}
%%
%%
%%5.UnstructuredDatasectionsmixdataofalltypes.
%%
%%6.Youshouldcompareadata'sDataTypeIdxwiththeseglobalTLCvariables
%%TypicaldefaultC-typesforthevalueofDataTypeIdx,whichcanbechanged
%%using#defineatcompiletime,areshown.
%%
%%TLCVariableCtypedefTypicalDefaultC-type
%%-------------------------------------------
%%tSS_DOUBLEreal_Tdouble
%%tSS_SINGLEreal32_Tfloat
%%tSS_INT32int32_Tint
%%tSS_INT16int16_Tshort
%%tSS_INT8int8_Tchar
%%tSS_UINT32uint32_Tunsignedint
%%tSS_UINT16uint16_Tunsignedshort
%%tSS_UINT8uint8_Tunsignedchar
%%tSS_BOOLEANboolean_Tunsignedchar
%%
%%Thenumberofbuilt-inSimulinkdatatypesisfoundintheDataTypesscope.
%%Thatis,::CompiledModel.DataTypes.NumSLBuiltInDataTypes
%%
%%7.Eachdatahasaclassdesignation.CurrentlyTMWhastheseclasses:
%%
%%Data.ClassDescription
%%=====================
%%scalarscalardata
%%vectorvectordata
%%row-mat2-Dmatinrowmajororder:data[row][col]
%%col-mat2-Dmatincolumnmajororder(MATLABstyle):data[col][row]
%%col-mat-ndN-Dmatin"stacked"columnmajororder(MATLABstyle)
%%
%%NearlyallmatriciesarerepresentedintrueMATLABfashion(i.e.,
%%columnmajororder).
%%
%%8.ScalardatahaveNumRows=1andNumCols=1.Vectordataisnon-oriented
%%inSimulink,however,itisbestrepresentedasacolumnvectorwith
%%NumRows=widthandNumCols=1.Thenumberofdimensions,NumDimentions,
%%forscalarsandvectorsis2.Fora2-DimensionalMxNmatrixdata,
%%NumRows=M,NumCols=NandNumDimensionsis2.N-Dimensionalmatriceshave
%%NumDimensions>2withDimensions[d1,d2,d3,...,dn]inMATLABfashion.
%%
%%9.TheTypefieldforDatarecordscanhavethesevalues
%%
%%unknown-Unknownusage.Usuallyaninternal"state"variable.
%%signal-ASLsignalparentedbyablock
%%state-ASLstateparentedbyablock
%%data-DataparentedbySFmachine
%%parameter-AparameterwithinSLparentedby1ormoreblocksand
%%optionallyparentedbyaSFmachine.
%%
%%10.SimulinkDataObjectsareincludedasfollows
%%
%%Data{
%%:
%%HasObject1
%%Object{
%%Package
%%Class
%%ObjectProperties{
%%:
%%}
%%}
%%}
%%
%%whereObjectPropertiesisareferencetotheobject'sproperties,and
%%isonlyincludedwhenHasObject=1.
%%
%%11.SimulinkBusobjects(signals)areincludedasfollows
%%
%%Data{
%%:
%%IsStruct1
%%StructInfo'::CompiledModel.GlobalMemoryMap.NonVirtualStructures.Bus[1]'
%%:
%%}
%%
%%whereStructInfoisareferencetothedata'sBusproperties,andis
%%onlyincludedifIsStruct=1.
%%
%%StructInforeferstoarecordinGlobalMemoryMap.NonVirtualStructures,thisrecordis
%%recordofalltheBusStructuresinthemodel.Thelayoutofthisrecordis
%%asfollows
%%
%%GlobalMemoryMap{
%%NonVirtualStructures{
%%NumNonVirtualBuses1
%%Bus{
%%Name"Bus1"
%%Description""
%%Header""
%%DataTypeIdx14
%%NumElements2
%%BusElement{
%%Name"BusElem1"
%%Class"scalar"
%%DataTypeIdx0
%%IsComplex0
%%IsFixedPoint0
%%IsStruct0
%%NumCols1
%%NumDimensions2
%%NumRows1
%%}
%%BusElement{
%%Name"BusElem2"
%%Class"col-mat"
%%DataTypeIdx0
%%IsComplex0
%%IsFixedPoint0
%%IsStruct0
%%NumCols4
%%NumDimensions2
%%NumRows3
%%}
%%}
%%}
%%}
%%
%%oTheBusPropertiescanbedirectlyaccessedfromthedata.
%%%assignisDataABus=data.IsStruct
%%%ifisDataABus
%%%assignbusName=data.StructInfo.Name
%%%assignbusDescription=data.StructInfo.Description
%%:
%%%assignnumBusElementsInData=data.StructInfo.NumElements
%%%foreacheIdx=numBusElementsInData
%%%assignbusElementName=data.StructInfo.BusElement[eIdx].Name
%%%assignbusElementNRows=data.StructInfo.BusElement[eIdx].NumRows
%%:
%%%endforeach
%%%endif
%%
%%Note:ThefieldsinBusElementrecordcloselymatchthatofaData
%%(unstructuredorstructured)inGlobalMemoryMap.
%%
%%oIfaBusElementisaBusstructureitself,thenareferencetoBus's
%%propertiesisaddedtotheBusElementrecord.Fore.g
%%
%%GlobalMemoryMap{
%%:
%%NonVirtualStructures{
%%:
%%Bus{
%%Name"Bus1"
%%Description""
%%Header""
%%DataTypeIdx14
%%NumElements2
%%BusElement{
%%Name"BusElem1"
%%:
%%IsStruct0
%%}
%%BusElement{
%%Name"BusElem2"
%%:
%%IsStruct1
%%StructInfo{
%%Name"SubBus"
%%Description""
%%Header""
%%DataTypeIdx14
%%NumElements2
%%BusElement{
%%Name"BusSubElem1"
%%:
%%}
%%BusElement{
%%Name"BusSubElem2"
%%:
%%}
%%}
%%}
%%}
%%}
%%}
%%
%%12.YouproducetheGlobalMemoryMapbysettingglobalvariablesinyour
%%systemtargetfile.TheabstractforSLibMapDatadescribeshowtoavoid
%%generatingindividualmaps.
%%
%%%%directcodegentocreateadatamap,excludingexternaloutputs
%%
%%%assignGenerateInterfaceAPI=1
%%
%%%include"commonsetup.tlc"
%%
%%%%doyourstuff
%%
%%%include"commonentry.tlc"/%mapisproducedwithgeneratedcode%/
%%
%%%%domoreofyourstuff
%%
%%YoucaninterogatethememorymapusingtheTLCdebugger.Alternatively,
%%youcanpass::CompiledModel.GlobalMemoryMapintotheMATLABbaseworkspace
%%byassigningInterfaceAPIAsMatlabVar.Forexample,
%%
%%%assignInterfaceAPIAsMatlabVar="foo"
%%
%%createsMATLABvariablefoo,andmirrorsGlobalMemoryMap.
%%
%%13.Youcangetaslightboostinmapperformanceifyouturnoffthe
%%symbolnameconflictresolutioncode(codetocheckconflictsbetween
%%Simulinksignals,parametersandStateflowdata).Toturnoffthe
%%checkingusingthisassignment
%%
%%%assignGMMConflictChecking=0
%%
%%Notethatthedefaultvalueis1(on).
%%
%%
%%Example
%%=======
%%
%%ThefollowingGlobalMemoryMapexamplesummarizesthespecification.
%%Mostfieldsareself-explanatory.Fieldsrequiringadditionalexplanation
%%overwhat'sbeendescribedcontainabriefdescription.
%%
%%GlobalMemoryMap{
%%NumStructuredData4
%%NumUnstructuredData1
%%NumCustomData2
%%StructuredData{
%%Name"rtB"
%%NumSections2
%%NumTotalElements5#sumofallstucture
%%#elementsincludingwidth
%%#andcomplexity.Thisvalue
%%#isusedtodeterminethe
%%#structuresizeforaCPU
%%#withasingleword
%%#length(e.g.,TMS320xx)
%%
%%DataDefaults{#ProvidesDefaultvaluesfor
%%Classscalar#structureddatavariablesthat
%%HasObject0#arenotexplicitlywritteninthe
%%IsFixedPoint0#structureddatarecords
%%IsStruct0
%%NumCols1
%%NumDimensions2
%%NumRows1
%%Permission"rw"
%%PPIf""
%%PPEndIf""
%%Type"signal"
%%}
%%Section{
%%DataTypeIdx0
%%IsComplex0
%%BaseAddr"&rtB.foo[0]"
%%NumElements4#sumofsectionelements
%%NumData2
%%Data{
%%NamertB.foo
%%Typesignal
%%IsStruct0#noassociatedBusStructure
%%IsFixedPoint0
%%HasObject0#doesnothaveassociatedUDDobject
%%Permissionro#read-only(ro)vs.read-write(rw)
%%BaseAddr&rtB.foo[0]#baseaddressofthisdata
%%OffsetFromBaseAddr0#Offsetfrom&rtB.foo[0].
%%#Forexample,ifDataTypeIdx
%%#mapsto"double",thenyou
%%#areXnumberofdoublesfrom
%%#thesection'sbaseaddress
%%#(theoffsetincludeswidth
%%#andcomplexitysoyoudon'tneed
%%#toworryaboutthosedetails).
%%Classvector
%%NumDimensions2
%%NumRows3
%%NumCols1
%%}
%%Data{
%%NamertB.vout
%%Typesignal
%%IsStruct0
%%IsFixedPoint0
%%HasObject0
%%Permissionro
%%BaseAddr&rtB.vout
%%OffsetFromBaseAddr3
%%Classscalar
%%NumDimensions2
%%NumRows1
%%NumCols1
%%}
%%}
%%Section{
%%DataTypeIdx15
%%IsComplex0
%%IsFixedPoint1
%%BaseAddr"&rtB.fpsignal"
%%NumElements1
%%NumData1
%%Data{
%%NamertB.fpsignal
%%Typesignal
%%IsStruct0
%%IsFixedPoint1
%%HasObject0
%%Permissionro
%%BaseAddr&rtB.fpsignal
%%OffsetFromBaseAddr0
%%Classscalar
%%NumDimensions2
%%NumRows1
%%NumCols1
%%FixedPointInfo{
%%NumBits32
%%IsSigned1
%%FixedExp-24
%%FracSlope1.0
%%Bias2000.0
%%Scalinguniform
%%}
%%}
%%}
%%}
%%StructuredData{
%%Name"rtP"
%%NumSections1
%%NumTotalElements2
%%DataDefaults{
%%Classscalar
%%HasObject0
%%IsStruct0
%%IsFixedPoint0
%%NumCols1
%%NumDimensions2
%%NumRows1
%%Permission"rw"
%%PPIf""
%%PPEndIf""
%%Type"parameter"
%%}
%%Section{
%%DataTypeIdx0
%%IsComplex1
%%NumElements2
%%BaseAddr"&rtP.k.re"
%%NumData1
%%Data{
%%NamertP.k
%%Typeparameter
%%HasObject0
%%IsStruct0
%%IsFixedPoint0
%%HasObject0
%%Permissionrw
%%BaseAddr&rtP.k
%%OffsetFromBaseAddr0
%%Classscalar
%%NumDimensions2
%%NumRows1
%%NumCols1
%%IsTransformed0#parametertransformation(0/1)
%%Value0.0
%%}
%%}
%%}
%%StructuredData{
%%Name"rtDWork"
%%NumSections1
%%NumTotalElements1
%%DataDefaults{#ProvidesDefaultvaluesfor
%%Classscalar#structureddatavariablesthat
%%HasObject0#arenotexplicitlywritteninthe
%%IsFixedPoint0#structureddatarecords
%%IsStruct0
%%NumCols1
%%NumDimensions2
%%NumRows1
%%Permission"rw"
%%PPIf""
%%PPEndIf""
%%Type"state"
%%}
%%Section{
%%DataTypeIdx0
%%IsComplex1
%%NumElements2
%%BaseAddr"&rtDWork.foo_state"
%%NumData2
%%Data{
%%NamertDWork.foo_state
%%Typestate
%%IsStruct0
%%IsFixedPoint0
%%HasObject0
%%Permissionro
%%BaseAddr&rtDWork.foo_state
%%OffsetFromBaseAddr0
%%Classscalar
%%NumDimensions2
%%NumRows1
%%NumCols1
%%}
%%Data{
%%NamertDWork.foo_mydata
%%Typeunknown
%%IsStruct0
%%IsFixedPoint0
%%HasObject0
%%Permissionro
%%BaseAddr&rtDWork.foo_mydata
%%OffsetFromBaseAddr1
%%Classscalar
%%NumDimensions2
%%NumRows1
%%NumCols1
%%}
%%}
%%}
%%StructuredData{
%%Name"rtX"
%%NumSections1
%%NumTotalElements1
%%DataDefaults{#ProvidesDefaultvaluesfor
%%Classscalar#structureddatavariablesthat
%%HasObject0#arenotexplicitlywritteninthe
%%IsFixedPoint0#structureddatarecords
%%IsStruct0
%%NumCols1
%%NumDimensions2
%%NumRows1
%%Permission"rw"
%%PPIf""
%%PPEndIf""
%%Type"state"
%%}
%%Section{
%%DataTypeIdx0
%%IsComplex0
%%NumElements1
%%BaseAddr"&rtX.Cont_Integrator"
%%NumData1
%%Data{
%%NamertX.Cont_Integrator
%%Typestate
%%IsStruct0
%%IsFixedPoint0
%%HasObject0
%%Permissionro
%%BaseAddr&rtX.Cont_Integrator
%%OffsetFromBaseAddr0
%%Classscalar
%%NumDimensions2
%%NumRows1
%%NumCols1
%%}
%%}
%%}
%%UnstructuredData{
%%Name"RTWunstructureddata"
%%NumTotalElements2
%%NumData2
%%DataDefaults{#ProvidesDefaultvaluesfor
%%Access"direct"#unstructureddatavariablesthat
%%Classscalar#arenotexplicitlywritteninthe
%%DataTypeIdx0#unstructureddatarecords
%%HasObject0
%%IsStruct0
%%IsComplex0
%%IsFixedPoint0
%%IsDefined0
%%NumCols1
%%NumDimensions2
%%NumRows1
%%Permission"rw"
%%PPIf""
%%PPEndIf""
%%Type"signal"
%%}
%%Data{
%%Namek1
%%Typesignal#signal,parameter,state,data
%%DataTypeIdx15#
%%IsStruct0#0/1
%%IsComplex0#0/1
%%IsFixedPoint1#0/1
%%IsDefined1#0/1:
%%#0:Dataisnotdefinedingeneratedcode.
%%#Dataisexpectedtobedefinedby
%%#externalcode.
%%#Forreferencemodelcode,datacould
%%#bedefinedintheparent/topmodelcode.
%%#1:Dataisdefinedinthegeneratedcode.
%%HasObject0
%%BaseAddr"&k1"#
%%Accessindirect#memoryaccess:direct,indirect
%%Permissionro#memorypermission:ro,rw
%%Classscalar#scalar,vector,col-mat,row-mat
%%#Note:Youaccessa3x4matrixAas
%%#A[colIdx][rowIdx]andA[roxIdx][rowIdx]
%%#forcolumnmajorandrow-majororder,
%%#respectively.Non-inlinedS-Functions
%%#matricesarestoredincolumnmajor
%%#order.Allothermatricesarestored
%%#inrowmajororder.
%%NumDimensions2
%%NumRows1
%%NumCols1
%%FixedPointInfo{
%%NumBits16
%%IsSigned1
%%FixedExp-4
%%FracSlope1.0
%%Bias0.0
%%}
%%}
%%Data{
%%Namek2
%%Typeparameter
%%DataTypeIdx0
%%IsStruct0#0/1
%%IsComplex0
%%IsFixedPoint0
%%IsDefined1#0/1:
%%HasObject0
%%BaseAddr"&k2"
%%Accessdirect
%%Permissionrw
%%Classscalar
%%NumDimensions2
%%NumRows1
%%NumCols1
%%IsTransformed0
%%Value100.0
%%}
%%}
%%CustomData{
%%NameStruct
%%PackageSimulink
%%FullNameSimulink::Struct
%%NumData1
%%Version1
%%DataDefaults{#ProvidesDefaultvaluesforCustomDatavariables
%%#thatarenotexplicitlywritteninthe
%%#Customdatarecords
%%Access"direct"
%%Classscalar
%%DataTypeIdx0
%%HasObject1
%%IsStruct0
%%IsComplex0
%%IsFixedPoint0
%%Permission"rw"
%%PPIf""
%%PPEndIf""
%%Type"parameter"
%%}
%%Data{
%%Namek3
%%Typeparameter#signal,parameter,state,data
%%DataTypeIdx15#
%%IsStruct0#0/1
%%IsComplex0#0/1
%%IsFixedPoint1#0/1
%%HasObject1
%%Object::CompiledModel.ModelParameters.Parameter[4].Object
%%BaseAddr"&k3"#
%%IsTransformed0
%%Permissionro#memorypermission:ro,rw
%%Classscalar#scalar,vector,col-mat,row-mat
%%NumDimensions2
%%NumRows1
%%NumCols1
%%Value145
%%FixedPointInfo{
%%NumBits16
%%IsSigned1
%%FixedExp-4
%%FracSlope1.0
%%Bias0.0
%%}
%%}
%%}
%%CustomData{
%%NameDefine
%%PackageSimulink
%%FullNameSimulink::Define
%%NumData1
%%Version1
%%Data{
%%Namek3
%%Typeparameter#signal,parameter,state,data
%%DataTypeIdx15#
%%IsStruct0#0/1
%%IsComplex0#0/1
%%IsFixedPoint1#0/1
%%HasObject1
%%Object::CompiledModel.ModelParameters.Parameter[5].Object
%%BaseAddraddressnotsupportedfor#define
%%IsTransformed0
%%Permissionro#memorypermission:ro,rw
%%Classscalar#scalar,vector,col-mat,row-mat
%%NumDimensions-1
%%Value112
%%FixedPointInfo{
%%NumBits16
%%IsSigned1
%%FixedExp-4
%%FracSlope1.0
%%Bias0.0
%%}
%%}
%%}
%%}
%%
 
%if EXISTS("_GLOBALMAPLIB_") == 0
%assign _GLOBALMAPLIB_ = 1
 
%%=============================================================================
%%AddglobalTLCvariablesto::CompiledModel
%%=============================================================================
 
%%Thesevariablesareusedtoenforcetheorderdependencyinwhich
%%mapsaregenerated.Signalsmustbegeneratedbeforeparametersand
%%parametersmustbegeneratedbeforeStateflowdata.
 
%<LibAddToCompiledModel("CustomInterfaceAPIGenerated", 0)>
%<LibAddToCompiledModel("InterfaceAPIGenerated", 0)>
%<LibAddToCompiledModel("BlockOutputsMapped", 0)>
%<LibAddToCompiledModel("ExternalInputsMapped", 0)>
%<LibAddToCompiledModel("ParametersMapped", 0)>
%<LibAddToCompiledModel("StateflowDataMapped", 0)>
 
%%Thesevariablescontrolwhichmapsaregenerated.
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%TopTester:test/toolbox/simulink/variants/variantBus/tVariantBusGecks.m
%%
%if !EXISTS("MapBlockOutputs")
  %assign MapBlockOutputs = 1
%endif
%if !EXISTS("MapExternalInputs")
  %assign MapExternalInputs = 1
%endif
%if (SLibIsERTTarget() && ...
  ((!SLibIsDeploymentDiagramType() && ConfigSet.GenerateTestInterfaces) || ...
   SLibFcnProtoCtrlActive()))
  %assign MapExternalOutputs = 1
%elseif !EXISTS("MapExternalOutputs")
  %assign MapExternalOutputs = 0
%endif
%if !EXISTS("MapCustomExternalOutputs")
  %assign MapCustomExternalOutputs = 1
%endif
%if !EXISTS("MapParameters")
  %assign MapParameters = 1
%endif
%if !EXISTS("MapStateflow")
  %assign MapStateflow = 1
%endif
%if !EXISTS("MapDWork")
  %assign MapDWork = 1
%endif
%if !EXISTS("MapZeroCrossings")
  %assign MapZeroCrossings = 1
%endif
%if !EXISTS("MapContStates")
  %assign MapContStates = 1
%endif
%if !EXISTS("MapDerivatives")
  %assign MapDerivatives = 1
%endif
%if !EXISTS("GMMConflictChecking")
  %assign GMMConflictChecking = 1
%endif
%if !EXISTS("MapBlockHierarchy")
  %assign MapBlockHierarchy = 1
%endif
 
%<LibAddToCompiledModel("MapBlockOutputs", MapBlockOutputs)>
%<LibAddToCompiledModel("MapExternalInputs", MapExternalInputs)>
%<LibAddToCompiledModel("MapExternalOutputs", MapExternalOutputs)>
%<LibAddToCompiledModel("MapCustomExternalOutputs", MapCustomExternalOutputs)>
%<LibAddToCompiledModel("MapParameters", MapParameters)>
%<LibAddToCompiledModel("MapStateflow", MapStateflow)>
%<LibAddToCompiledModel("MapDWork", MapDWork)>
%<LibAddToCompiledModel("MapZeroCrossings", MapZeroCrossings)>
%<LibAddToCompiledModel("MapContStates", MapContStates)>
%<LibAddToCompiledModel("MapDerivatives", MapDerivatives)>
%<LibAddToCompiledModel("GMMConflictChecking", GMMConflictChecking)>
%<LibAddToCompiledModel("MapBlockHierarchy", MapBlockHierarchy)>
 
%%Function:SLibGetGlobalMemoryDataRecord======================================
%%Abstract:
%%ReturnthedatarecordintheGlobalMemoryMapcorrespondingto
%%thespecifiedMemoryMapIdx.
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants9.m
%%TopTester:test/toolbox/simulink/blocks/lib_Sources/Ground/rtw/tStringSupport.m
%%
%function SLibGetGlobalMemoryDataRecord(memoryMapIdx) void
   
  %assign structIdx = memoryMapIdx[0]
  %assign secIdx = memoryMapIdx[1]
  %assign dataIdx = memoryMapIdx[2]
 
  %assign retVal = []
 
  %with ::CompiledModel.GlobalMemoryMap
    %if dataIdx == -1 %% Local / reused data
      %assign retVal = []
    %elseif secIdx == -1 %% Unstructured data
      %assign retVal = UnstructuredData.Data[dataIdx]
       
    %elseif structIdx == -1 %% Custom data
      %assign retVal = CustomData[secIdx].Data[dataIdx]
       
    %else %% Structured data
      %assign section = StructuredData[structIdx].Section[secIdx]
      %assign retVal = section.Data[dataIdx]
    %endif
  %endwith
 
  %return retVal
%endfunction
 
 
%%Function:SLibMapData=======================================================
%%Abstract:
%%Mapgenerateddatastructuresthatdonothavecustomstorage
%%class.
%%
%%Bydefaultnotalldataismapped.Youcanindividuallycontrolwhich
%%datastructuresaremappedbysettingglobalTLCvariablesto0or1
%%priortoincluding"codegenentry.tlc"or"commonsetup.tlc".Possible
%%flagstosetare:
%%
%%MapBlockOutputs
%%MapExternalInputs
%%MapExternalOutputs
%%MapParameters
%%MapStateflow
%%MapDWork
%%MapContStates
%%MapDerivatives
%%
%%Youcangetaboostinmapperformanceifyouturnoffthesymbol
%%nameconflictresolutioncode(codethatchecksthatnoconflicts
%%areeverencounteredamongSimulinksignals,parameters,Stateflow
%%data,etc.)Thisisachievedwith
%%
%%%assignGMMConflictChecking=0%%defaultvalueis1
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%
%function SLibMapData() void
   
  %if GenerateClassInterface
    %if !ISFIELD(::CompiledModel, "InGeneratingGMM")
      %<LibAddToCompiledModel("InGeneratingGMM", TLC_TRUE)>
    %endif
  %endif
 
  %if InterfaceAPIGenerated == 1
 
    %if GenerateClassInterface
      %assign ::CompiledModel.InGeneratingGMM = TLC_FALSE
    %endif
 
    %% Different API call SLibMapData at different locations.
    %return ""
  %endif
   
  %assign ::CompiledModel.InterfaceAPIGenerated = 1
 
%%sendmessagetocommandwindow
%if RTWVerbose
%selectfile STDOUT
### Generating TLC interface API.
%selectfile NULL_FILE
%endif
 
  %assign ::CompiledModel.BlockOutputsMapped = 0
  %assign ::CompiledModel.ExternalInputsMapped = 0
  %assign ::CompiledModel.ParametersMapped = 0
  %assign ::CompiledModel.StateflowDataMapped = 0
 
  %assign lastBlockFcn = ::BlockFcn
  %if ::BlockFcn == "Unknown"
    %assign ::BlockFcn = "GlobalMap"
  %endif
   
  %if MapBlockOutputs
    %<FcnMapBlockIO()>
  %endif
   
  %if MapExternalInputs
    %<FcnMapExternalInputs()>
  %endif
   
  %% NOTE: external input and block I/O signals must be mapped prior to
  %% parameters and Stateflow data for proper symbol conflict resolution.
  %% This dependency is explicitly enforced by using the global
  %% TLC variables created above.
 
  %if MapParameters
    %<FcnMapParameters()>
  %endif
   
  %if MapStateflow
    %<FcnMapStateflowData()>
  %endif
   
  %if MapDWork
    %<FcnMapDWork()>
  %endif
 
  %if MapDWork || MapParameters || MapBlockOutputs || MapExternalInputs || MapExternalOutputs
    %<FcnMapDataGroups()>
  %endif
   
  %if MapContStates
    %<FcnMapContStates()>
  %endif
   
  %if MapDerivatives
    %<FcnMapContStateDerivatives()>
  %endif
   
  %if MapExternalOutputs
    %<FcnMapExternalOutputs()>
  %endif
   
  %if MapBlockHierarchy
    %<FcnMapBlockHierarchy()>
  %endif
   
  %% internal testing facility. Set InterfaceAPITestFile2
  %% to the name of the TLC file which contains your map
  %% validation code. For example, InterfaceAPITestFile2="mytest.tlc"
  %if EXISTS("InterfaceAPITestFile2")
    %assign stdText = "### Writing custom code from %<InterfaceAPITestFile2>"
    %<LibWriteToStandardOutput(stdText)>
    %include "%<InterfaceAPITestFile2>"
  %endif
   
  %assign ::BlockFcn = lastBlockFcn
   
  %if GenerateClassInterface
    %assign ::CompiledModel.InGeneratingGMM = TLC_FALSE
  %endif
 
%endfunction
 
 
%%Function:SLibMapCustomData=================================================
%%Abstract:
%%Mapgenerateddatastructuresthathavecustomstorageclass.
%%
%%Bydefaultnotalldataismapped.Youcanindividuallycontrolwhich
%%datastructuresaremappedbysettingglobalTLCvariablesto0or1
%%priortoincluding"codegenentry.tlc"or"commonsetup.tlc".Possible
%%flagstosetare:
%%
%%MapBlockOutputs
%%MapExternalInputs
%%MapParameters
%%MapDWork
%%
%%Youcangetaboostinmapperformanceifyouturnoffthesymbol
%%nameconflictresolutioncode(codethatchecksthatnoconflicts
%%areeverencounteredamongSimulinksignals,parameters,Stateflow
%%data,etc.)Thisisachievedwith
%%
%%%assignGMMConflictChecking=0%%defaultvalueis1
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function SLibMapCustomData() void
  %assign ::CompiledModel.CustomInterfaceAPIGenerated = 1
   
  %% send message to command window
  %if RTWVerbose
%selectfile STDOUT
### Generating TLC interface API for custom data
%selectfile NULL_FILE
  %endif
 
  %assign ::CompiledModel.BlockOutputsMapped = 0
  %assign ::CompiledModel.ExternalInputsMapped = 0
  %assign ::CompiledModel.ParametersMapped = 0
 
  %<PrepareForMappingBlockIO()>
   
  %if MapCustomExternalOutputs
    %<FcnMapCustomExternalOutputs()>
  %endif
   
  %% MapBlockOutputs must be run before MapExternalInputs
 
  %if MapBlockOutputs
    %<FcnMapCustomBlockIO()>
  %endif
   
  %if MapExternalInputs
    %<FcnMapCustomExternalInputs()>
  %endif
   
   %% NOTE: external input and block I/O signals must be mapped prior to
  %% parameters and Stateflow data for proper symbol conflict resolution.
  %% This dependency if explicitly enforced by using the global
  %% TLC variables created above.
 
  %if MapParameters
    %<FcnMapCustomParameters()>
  %endif
   
  %if MapDWork
    %<FcnMapCustomDWork()>
  %endif
 
  %if MapZeroCrossings
    %<FcnMapCustomZeroCrossings()>
  %endif
   
%endfunction
 
 
%%Function:SLibPostMapData===================================================
%%Abstract:
%%Nowthatthemapiscreated,dosomethingwithit
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function SLibPostMapData() void
  %% remove "internal use" only fields
  %<FcnPostMapCleanup()>
   
  %% create GlobalMemoryMap as MATLAB variable
  %if EXISTS("InterfaceAPIAsMatlabVar")
    %assign mlVar = InterfaceAPIAsMatlabVar
    %if FEVAL("tlc2m",mlVar, GlobalMemoryMap)
      %warning Created GlobalMemoryMap as MATLAB variable: %<mlVar>
    %else
      %warning Unable to create GlobalMemoryMap as MATLAB variable: %<mlVar>
    %endif
  %endif
   
  %% internal testing facility. Set InterfaceAPITestFile
  %% to the name of the TLC file which contains your map
  %% validation code. For example, InterfaceAPITestFile="mytest.tlc"
  %if EXISTS("InterfaceAPITestFile")
    %include "%<InterfaceAPITestFile>"
  %endif
%endfunction
 
 
%%=============================================================================
%%CreateGlobalMemoryMapandattachitto::CompiledModel
%%=============================================================================
 
%%Function:FcnCreateGlobalMemoryMap==========================================
%%Abstract:
%%CreatestheGlobalMemoryMapandattachesitto::CompiledModel.
%%
%%NotethatInstanceCacheandSignalInstanceCacheareforinternaluse
%%only,andareremovedinFcnPostMapCleanup.
%%
%function FcnCreateGlobalMemoryMap() void
  %assign isDefined = ...
    ISEQUAL(::CompiledModel.ModelReferenceTargetType,"NONE") ? ...
    TLC_TRUE : TLC_FALSE
  %addtorecord ::CompiledModel /
  GlobalMemoryMap { /
    NumStructuredData 0 /
    NumUnstructuredData 1 /
    NumCustomData 0 /
    CustomDataIndexHash { /
    } /
    ModelParameters { /
      NumModelParameters 0 /
      InstanceCache { /
        NumCachedVariables 0 /
      } /
      SignalInstanceCache { /
        NumCachedSignals 0 /
      } /
    } /
    NonVirtualStructures { /
      NumNonVirtualBuses 0 /
      BusStructureHash { /
      } /
    } /
    FixedPointMaps { /
      NumFixPtTypes 0 /
      FixPtTypeHash { /
      } /
    } /
    UnstructuredData { /
      Name "RTW unstructured data" /
      NumTotalElements 0 /
      NumData 0 /
      DataDefaults { /
        Access "direct" /
        Class "scalar" /
    DataTypeIdx 0 /
        HasObject TLC_FALSE /
    IsComplex TLC_FALSE /
        IsFixedPoint TLC_FALSE /
    IsStruct TLC_FALSE /
        NumCols 1 /
        NumDimensions 2 /
        NumRows 1 /
    Permission "rw" /
        PPIf "" /
        PPEndIf "" /
    Type "parameter" /
        IsDefined isDefined /
      } /
    } /
  }
%endfunction
 
%<FcnCreateGlobalMemoryMap()>
 
 
 
%%Function:FcnAddNonUniformElement========================================
%%Abstract:
%%AddelementscalinginformationtoFixedPointInforecord.
%%
%function FcnAddNonUniformElement(fpInfo, dtIdx) void
  %assign dtDefine = DataTypes.DataType[dtIdx]
  %addtorecord fpInfo /
  ElementScaling { /
    FixedExp dtDefine.FixedExp; /
    FracSlope dtDefine.FracSlope; /
    Bias dtDefine.Bias /
  }
%endfunction
 
%%Function:FcnGetUniformFixPtTypeInGMM======================================
%%Abstract:
%%GettheindexofauniformlyscaledFixedPointRecordin
%%GlobalMemoryMap.FixedPointMaps,whereFixedPointMapsisahashed
%%collectionofallFixedPointdatatypes.IftheFixedPoint
%%informationdoesnotexistinthehashedmap,thenitis
%%addedtothemapandthenewindexisreturned
%%
%%GlobalMemoryMap{
%%:
%%FixedPointMaps{
%%NumFixPtTypes1
%%FixPtRecord{
%%Scaling
%%NumBits
%%NumRequiredBits
%%IsSigned
%%FixedExp
%%FracSlope
%%Bias
%%}
%%}
%%}
%%
%%UsethereturnedindextoaddareferencetotheFixPtRecordinyourdata
%%forexample
%%%addtorecorddataFixedPointInfoFixedPointMaps.FixPtRecord[returnIndex]
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants9.m
%%
%function FcnGetUniformFixPtTypeInGMM(dataTypeRec) void
  %assert (dataTypeRec.IsFixedPoint == 1)
  %assign hashKey = "DataTypeId%<dataTypeRec.Id>"
  %with GlobalMemoryMap.FixedPointMaps
    %if ISFIELD(FixPtTypeHash, hashKey)
      %assign fxpIdx = GETFIELD(FixPtTypeHash, hashKey)
    %else
      %assign fxpIdx = NumFixPtTypes
      %addtorecord GlobalMemoryMap.FixedPointMaps /
      FixPtRecord { /
        Scaling "uniform"; /
    NumBits dataTypeRec.ActualBits; /
    NumRequiredBits dataTypeRec.RequiredBits; /
    IsSigned dataTypeRec.IsSigned; /
    FixedExp dataTypeRec.FixedExp; /
    FracSlope dataTypeRec.FracSlope; /
    Bias dataTypeRec.Bias /
      }
      %addtorecord FixPtTypeHash %<hashKey> fxpIdx
      %assign GlobalMemoryMap.FixedPointMaps.NumFixPtTypes = NumFixPtTypes + 1
    %endif
  %endwith
  %return fxpIdx
%endfunction
 
%%Function:FcnAddFixedPointInfo=============================================
%%Abstract:
%%Addreleventfixed-pointinformationtoarecord.Fixed-pointsignals
%%alwayshaveuniformscaling.Fixed-pointparameterscanhaveuniformor
%%non-uniformscaling.
%%
%%data:globalmemorymapdatarecordtowhichwe'lladdFixedPointInfo
%%record:referenceofdatatobemapped
%%TopTester:test/toolbox/fixpoint/fixpt_autoscale/MLFB/apply_workflow/t_edit_operations2.m
%%
%function FcnAddFixedPointInfo(data, record) void
  %switch record.RecordType
    %case "BlockOutput"
    %case "ExternalInput"
    %case "ModelParameter"
    %case "DWork"
    %case "ExternalOutput"
      %assign dtDefine = DataTypes.DataType[LibGetRecordDataTypeId(record)]
      %assign scaling = "uniform"
      %break
    %default
      %<LibReportFatalError("unknown record type: %<record.RecordType>.")>
  %endswitch
   
  %if scaling == "uniform"
    %assign fxpIdx = FcnGetUniformFixPtTypeInGMM(dtDefine)
  %endif
   
  %addtorecord data /
  FixedPointInfo GlobalMemoryMap.FixedPointMaps.FixPtRecord[fxpIdx]
%endfunction
 
 
%%Function:FcnAddObjectProperties===========================================
%%Abstract:
%%AddSimulinkdataobjectpropertyinfo.
%%
%function FcnAddObjectProperties(data, record) void
  %if record.HasObject
    %assign data.HasObject = TLC_TRUE
    %addtorecord data Object record.Object
  %endif
%endfunction
 
%%Function:StripDollarCharFromLUTType===========================================
%%Abstract:
%%Strip'$'characterfromLUTtypename
%%
%function StripDollarCharFromLUTType(lutType)
    %assign p = CGMODEL_ACCESS("String.find", lutType, "$")
    %if p >= 0
        %assign length = CGMODEL_ACCESS("String.length", lutType)
        %return CGMODEL_ACCESS("String.substr", lutType, 0, p) + CGMODEL_ACCESS("String.substr", lutType, p+1, length-p-1)
    %else
        %return lutType
    %endif
%endfunction
 
%%Function:FcnAddBusStructure============================================
%%Abstract
%%AddsSimulinkBusinformationtodata.
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function FcnAddBusStructure(data, dataTypeIdx) void
  %if LibIsStructDataType(dataTypeIdx)
    %% if data type is Struct (Bus)
    %assign data.IsStruct = TLC_TRUE %% Set IsStruct to 1
    %% create a hashKey for the bus data type
    %assign busDataTypeIdx = dataTypeIdx
    %assign busName = LibGetDataTypeNameFromId(busDataTypeIdx)
    %assign busHashKey = busName
    %with GlobalMemoryMap.NonVirtualStructures
      %% Check if the Bus is already mapped in GlobalMemoryMap
      %if ISFIELD(BusStructureHash, busHashKey)
        %assign busIdx = GETFIELD(BusStructureHash, busHashKey)
      %else
        %% if not mapped, add the Bus to GlobalMemoryMap
        %assign busIdx = NumNonVirtualBuses
        %assign numElements = LibDataTypeNumElements(busDataTypeIdx)
        %addtorecord GlobalMemoryMap.NonVirtualStructures /
        Bus { /
        Name busName; /
        Description LibDescriptionForDataTypeIdx(busDataTypeIdx); /
        Header LibHeaderForDataTypeIdx(busDataTypeIdx) /
        DataTypeIdx busDataTypeIdx; /
        NumElements numElements /
        BusElementDefaults { /
        Class "scalar"; /
        DataTypeIdx 0; /
        IsComplex TLC_FALSE; /
        IsFixedPoint TLC_FALSE; /
        IsStruct TLC_FALSE; /
        NumDimensions 2; /
        NumRows 1; /
        NumCols 1; /
        Description ""; /
        DocUnits ""; /
        Max rtInf; /
        Min rtMinusInf /
      } /
    }
    %% add the new bus to the hashed record
    %assign busHashKey = StripDollarCharFromLUTType(busHashKey)
    %addtorecord BusStructureHash %<busHashKey> busIdx
    %% increment the number of Bus structures
    %assign GlobalMemoryMap.NonVirtualStructures.NumNonVirtualBuses = ...
      NumNonVirtualBuses + 1
    %% Add Elements to the Bus Structure
    %foreach elemIdx = numElements
      %<FcnAddBusElement(Bus[busIdx], elemIdx)>
    %endforeach
  %endif
  %% add a reference of the Bus to the data
  %addtorecord data StructInfo Bus[busIdx]
%endwith
%endif %% LibIsStructDataType(data.DataTypeIdx)
%endfunction
 
%%Function:FcnAddBusElement================================================
%%Abstract:
%%AddaSimulinkBusElementinformationtoaBusstructurerecordin
%%GlobalMemoryMap
%%gmmBusStructure-BusstructureinGlobalMemoryMap.NonVirtualStructures
%%elemIdx-elementnumber
%%TopTester:test/toolbox/rtw/targets/ert/model2model/pir2engine/tPir2EngineLutGecks04.m
%%TopTester:test/toolbox/simulink/variants/variantBus/tmMultiportBlockBasic2_VC1.m
%%
%function FcnAddBusElement(gmmBusStructure, elemIdx) void
  %with GlobalMemoryMap.NonVirtualStructures
    %assign busDTIdx = gmmBusStructure.DataTypeIdx
    %assign matND = "col-mat-nd"
    %assign mat2D = "col-mat"
    %if LibIsRowMajorLayout()
      %assign matND = "row-mat-nd"
      %assign mat2D = "row-mat"
    %endif
    %% Element Data Type attributes
    %assign elemDataTypeIdx = LibDataTypeElementDataTypeId(busDTIdx, elemIdx)
    %assign elemIsFixPt = LibDataTypeElementIsFixPt(busDTIdx, elemIdx)
     
    %% Element Dimensions
    %% In MATLAB, Scalar and Vector Bus Elements have NumDimensions=1 &
    %% Dimensions = [1] for scalar and [N] for 1-D vectors.
    %% To be consistent with how Dimensions are represented for DATA in
    %% GlobalMemoryMap, dimensions for Bus Elements are represented as
    %% following
    %% Scalar
    %% Class "scalar"
    %% NumDimensions 2
    %% NumRows 1
    %% NumCols 1
    %% Nx1 Vector
    %% Class "vector"
    %% NumDimensions 2
    %% NumRows N
    %% NumCols 1
    %% NxM Matrix
    %% Class "col-mat"
    %% NumDimensions 2
    %% NumRows N
    %% NumCols M
    %% N-D Matrix (highly unlikely for Bus Signals)
    %% Class "col-mat-nd"
    %% NumDimensions N
    %% NumRows -1
    %% NumCols -1
    %% Dimensions [N, M, P, ...]
    %assign numDims = LibDataTypeElementNumDimensions(busDTIdx, elemIdx)
    %assign dims = LibDataTypeElementDimensions(busDTIdx, elemIdx)
    %assign width = LibDataTypeElementWidth(busDTIdx, elemIdx)
    %if numDims == 1
      %assign numDims = 2
      %assign numRows = CAST("Number", dims[0])
      %assign numCols = 1
      %if width == 1
    %assign elemClass = "scalar"
      %else
    %assign elemClass = "vector"
      %endif
    %elseif numDims == 2
      %assign numRows = CAST("Number", dims[0])
      %assign numCols = CAST("Number", dims[1])
      %assign elemClass = "%<mat2D>"
    %else
      %assign numRows = -1
      %assign numCols = -1
      %assign elemClass = "%<matND>"
    %endif
    %addtorecord gmmBusStructure /
    BusElement { /
      Name LibDataTypeElementName(busDTIdx, elemIdx) /
    }
     
    %% Assign class if not scalar, otherwise inherit from Defaults
    %if elemClass != "scalar"
      %assign gmmBusStructure.BusElement[elemIdx].Class = elemClass
    %endif
     
    %% Assign dataType if not Double, otherwise inherit from Defaults
    %if elemDataTypeIdx > 0
      %assign gmmBusStructure.BusElement[elemIdx].DataTypeIdx = elemDataTypeIdx
    %endif
     
    %% Assign complexity if Complex, otherwise inherit from Defaults
    %if LibDataTypeElementIsComplex(busDTIdx, elemIdx)
      %assign gmmBusStructure.BusElement[elemIdx].IsComplex = TLC_TRUE
    %endif
     
    %% Add Fixed Point Information
    %if elemIsFixPt
      %assign gmmBusStructure.BusElement[elemIdx].IsFixedPoint = TLC_TRUE
      %assign fxpDataTypeRec = DataTypes.DataType[elemDataTypeIdx]
      %assign fxpIdx = FcnGetUniformFixPtTypeInGMM(fxpDataTypeRec)
      %addtorecord gmmBusStructure.BusElement[elemIdx] ...
    FixedPointInfo GlobalMemoryMap.FixedPointMaps.FixPtRecord[fxpIdx]
    %endif
     
    %% Check and add Dimensions to the Data record
    %if numDims > 2
      %addtorecord gmmBusStructure.BusElement[elemIdx] Dimensions dims
      %assign gmmBusStructure.BusElement[elemIdx].NumDimensions = numDims
    %else
      %if numRows > 1
    %assign gmmBusStructure.BusElement[elemIdx].NumRows = numRows
      %endif
      %if numCols > 1
    %assign gmmBusStructure.BusElement[elemIdx].NumCols = numCols
      %endif
    %endif
     
    %% Add Max/Min information
    %if LibDataTypeIsBus(busDTIdx)
                  
      %assign gmmBusStructure.BusElement[elemIdx].Description = ...
        LibDataTypeElementDescription(busDTIdx, elemIdx)
 
      %assign gmmBusStructure.BusElement[elemIdx].DocUnits = ...
        LibDataTypeElementDocUnits(busDTIdx, elemIdx)
       
      %assign elemMax = LibDataTypeElementMax(busDTIdx, elemIdx)
      %if elemMax != rtInf
        %assign gmmBusStructure.BusElement[elemIdx].Max = elemMax
      %endif
       
      %assign elemMin = LibDataTypeElementMin(busDTIdx, elemIdx)
      %if elemMin != rtMinusInf
        %assign gmmBusStructure.BusElement[elemIdx].Min = elemMin
      %endif
    %endif
     
    %% Add Bus Structure information
    %<FcnAddBusStructure(gmmBusStructure.BusElement[elemIdx], elemDataTypeIdx)>
     
  %endwith
%endfunction
 
 
%%Function:LibRTWRecord====================================================
%%Abstract:
%%Foragivenmemorymaprecord,returnthecorrespondingrecord;
%%ifnottherereturnempty
%%
%function LibRTWRecord(record)
  %if ISFIELD(record,"RTWRecord")
    %return record.RTWRecord
  %else
    %return []
  %endif
%endfunction
 
%%Function:LibGetDataWidth===================================================
%%Abstract:
%%Foragivenrecord,returnthewidth
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants3.m
%%
%function LibGetDataWidth(record) void
  %switch record.RecordType
    %case "ZcSignalInfo"
      %return LibGetRecordWidth(record)
 
    %case "BlockOutput"
      %return LibGetRecordWidth(record)
       
    %case "ModelParameter"
      %return LibGetRecordWidth(record)
       
    %case "DWork"
      %return FcnGetDWorkWidth(record)
       
    %case "ChartData"
      %return record.With
       
    %case "ContState"
      %return record.Width
       
    %case "ExternalInput"
      %return LibGetRecordWidth(record)
       
    %case "ExternalOutput"
      %return LibGetRecordWidth(record)
       
    %case "MachineData"
       
      %assign sfSize = CAST("Number", record.Size)
      %return sfSize == 0 ? 1 : sfSize
       
    %default
      %<LibReportFatalError("unknown record type: %<record.RecordType>")>
  %endswitch
%endfunction
 
%%Function:LibGetDataSymbolicWidth===========================================
%%Abstract:
%%Foragivenrecord,returnthewidth(asastring)
%%EventuallythisfunctionwillbereplacedbyLibGetDataSymbolicDims.
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function LibGetDataSymbolicWidth(record) void
  %if SLibIsNdIndexingFeatureOn()
    %return LibGetDataSymbolicDims(record)
  %else
    %if SLibIsRecordSupportedForSymbolicDimensions(record)
      %return LibGetRecordSymbolicWidth(record)
    %else
      %return "%<LibGetDataWidth(record)>"
    %endif
  %endif
%endfunction
 
%%Function:LibGetDataSymbolicDims===========================================
%%Abstract:
%%Foragivenrecord,returnthedimensions(asastring).
%%EventuallythisfunctionwillreplaceLibGetDataSymbolicWidth.
%%
%function LibGetDataSymbolicDims(record) void
  %if SLibIsRecordSupportedForSymbolicDimensions(record)
    %return LibGetRecordSymbolicDims(record)
  %else
    %return "%<LibGetDataWidth(record)>"
  %endif
%endfunction
 
%%Function:SLibIsRecordSupportedForSymbolicDimensions========================
%%Abstract:
%%Foragivenrecord,checkifitissupportedforsymbolicdimensions
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function SLibIsRecordSupportedForSymbolicDimensions(record) void
  %assign isSupported = TLC_FALSE
  %if (record.RecordType == "BlockOutput" || ...
       record.RecordType == "ModelParameter" || ...
       record.RecordType == "DWork" || ...
       record.RecordType == "ExternalInput" || ...
       record.RecordType == "ExternalOutput")
    %assign isSupported = TLC_TRUE
  %endif
  %return isSupported
%endfunction
 
%%Function:SLibIsGlobalDataRecWithNoExternalLinkage==========================
%%Abstract:
%%Foragivendatarecord(e.g.,BlockIO,ModelParameter,DWork),
%%returnifitmapstoglobaldatathatisnotaccessibleinexternalcode.
%%
%%Fordetails,see:SLibIsGlobalMapDataWithNoExternalLinkage
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function SLibIsGlobalDataRecWithNoExternalLinkage(record) void
 
  %% Get the global memory map data record
  %assign data = SLibGetGlobalMemoryDataRecord(record.MemoryMapIdx)
   
  %if TYPE(data) == "Scope"
    %return SLibIsGlobalMapDataWithNoExternalLinkage(data)
  %else
    %return TLC_FALSE
  %endif
 
%endfunction %% SLibIsGlobalDataRecWithNoExternalLinkage
   
   
%%Function:SLibIsGlobalMapDataWithNoExternalLinkage==========================
%%Abstract:
%%Foragivenglobalmemorymapdatarecord,
%%returnifitisnotaccessibleinexternalcode.
%%TopTester:test/toolbox/simulink/variants/tVariantGecks2.m
%%
%function SLibIsGlobalMapDataWithNoExternalLinkage(data) void
 
  %% Cannot interface to data with non-standard data layout
  %if (data.Class == "other")
    %return TLC_TRUE
  %endif
   
  %% Cannot interface to data with unknown data access
  %if ISFIELD(data, "Access") && (data.Access == "unknown")
    %return TLC_TRUE
  %endif
 
  %% Cannot interface to custom data with file scope
  %if ISFIELD(data, "Scope") && (data.Scope == "File")
    %return TLC_TRUE
  %endif
 
  %assign rtwRecord = LibRTWRecord(data)
  %% Function scoped data is not accessible
  %if !ISEMPTY(rtwRecord) && ISFIELD(rtwRecord,"isFcnScoped") && (rtwRecord.isFcnScoped != 0)
    %return TLC_TRUE
  %endif
   
  %return TLC_FALSE
 
%endfunction %% SLibIsGlobalMapDataWithNoExternalLinkage
   
   
%%Function:LibGetDataLayout==================================================
%%Abstract:
%%Foragivenrecord,returnavectorwiththefollowingformat
%%
%%["data-class",NumDimensions,[dim1,dim2,...,dimM],"optWidth"]
%%
%%Forexample,a4D,2D,vectorandscalardata,respectively
%%
%%3x3x2x5matrix:["col-mat-nd",4,[3,3,2,5],"[0]"]
%%3x4matrix:["col-mat",2,[3,4],"[0]"]
%%3(x1)vector:["vector",2,[3,1],"[0]"]
%%(1x1)scalar:["scalar",2,[1,1],""]
%%
%%TheoptWidthvalueishowthefirstelementisindexed.
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%TopTester:test/toolbox/simulink/variants/variantBus/tmMultiportBlockBasic2_VC1.m
%%TopTester:test/toolbox/simulink/variants/tTypesToPrivate.m
%%TopTester:test/toolbox/simulink/blocks/tmux_blkDialog.m
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants9.m
%%TopTester:test/toolbox/fixpoint/fixpt_autoscale/MLFB/apply_workflow/t_edit_operations2.m
%%
%function LibGetDataLayout(record) void
  %assign matND = "col-mat-nd"
  %assign mat2D = "col-mat"
  %if LibIsRowMajorLayout()
    %assign matND = "row-mat-nd"
    %assign mat2D = "row-mat"
  %endif
 
  %assign width = LibGetDataWidth(record)
  %switch record.RecordType
    %case "BlockOutput"
       
      %assign dims = LibGetRecordDimensions(record)
      %assign nDims = SIZE(dims, 1)
       
      %if nDims > 2
    %return ["%<matND>", %<nDims>, %<dims>, "[0]"]
      %elseif nDims == 2 && dims[0] != -1 && width > 1
    %assign nRows = dims[0]
    %assign nCols = dims[1]
    %return ["%<mat2D>", 2, [%<nRows>,%<nCols>], "[0]"]
      %elseif width > 1
    %return ["vector", 2, [%<width>,1], "[0]"]
      %else
        %return ["scalar", 2, [1,1], ""]
      %endif
      %break
       
    %case "ModelParameter"
       
      %assign mdlParam = record
      %assign dims = LibBlockParameterDimensions(mdlParam)
      %assign nDims = SIZE(dims, 1)
      %assign width = LibBlockParameterWidth(mdlParam)
      %assign nRows = dims[0]
      %assign nCols = width/nRows
 
      %if nDims > 2
    %return ["%<matND>", %<nDims>, %<dims>, "[0]"]
      %elseif nRows > 1 && nCols > 1
    %return ["%<mat2D>", 2, [%<nRows>,%<nCols>], "[0]"]
      %elseif width > 1
    %return ["vector", 2, [%<nRows>,%<nCols>], "[0]"]
      %else
      %return ["scalar", 2, [1,1], ""]
      %endif
      %break
       
    %case "DWork"
      %% A DWork record should have a CGTypeIdx field even if it does
      %% not have a Dimensions field
      %assign dims = LibGetRecordDimensions(record)
      %assign nDims = SIZE(dims, 1)
      %switch nDims
        %case 0
          %return ["scalar", 2, [1,1], ""]
        %case 1
          %if width == 1
              %return ["scalar", 2, [1,1], ""]
          %else
              %return ["vector", 2, [%,1], "[0]"]
          %endif
        %case 2
          %assign nRows = dims[0]
          %assign nCols = dims[1]
          %if nRows > 1 && nCols > 1
              %return ["%<mat2D>", 2, %<dims>, "[0]"]
          %else
              %% For DWorks output vector for row or column vectors
              %% or AUTOSAR PIMs will require root-level matrix I/O
              %% using one-dimensional arrays enabled.
              %return ["vector", 2, %<dims>, "[0]"]
          %endif
        %default
          %return ["%<matND>", %<nDims>, %<dims>, "[0]"]
      %endswitch
      %break
 
    %case "ContState"
      %if ISFIELD(record, "Dimensions")
        %% SF chart dwork record has dimension info
        %assign dims = record.Dimensions
        %assign nDims = SIZE(dims, 1)
        %switch nDims
          %case 0
            %return ["scalar", 2, [1,1], ""]
          %case 1
            %return ["vector", 2, [%,1], "[0]"]
          %case 2
            %return ["%<mat2D>", 2, %<dims>, "[0]"]
          %default
            %return ["%<matND>", %<nDims>, %<dims>, "[0]"]
        %endswitch
      %else
        %if width == 1
          %return ["scalar", 2, [1,1], ""]
        %else
          %return ["vector", 2, [%<width>,1], "[0]"]
        %endif
      %endif
      %break
       
    %case "ChartData"
      %assign dims = record.Dimensions
      %assign nDims = SIZE(dims, 1)
      %switch nDims
        %case 0
          %return ["scalar", 2, [1,1], ""]
        %case 1
          %return ["vector", 2, [%,1], "[0]"]
        %case 2
          %return ["%<mat2D>", 2, %<dims>, "[0]"]
        %default
          %return ["%<matND>", %<nDims>, %<dims>, "[0]"]
      %endswitch
      %break
       
    %case "ExternalInput"
      %assign ei = record
      %assign dims = LibGetRecordDimensions(ei)
      %assign nDims = SIZE(dims, 1)
      %if nDims > 2
    %return ["%<matND>", %<nDims>, %<dims>, "[0]"]
      %elseif nDims == 2 && width > 1
    %assign nRows = dims[0]
    %assign nCols = dims[1]
    %return ["%<mat2D>", 2, [%<nRows>,%<nCols>], "[0]"]
      %elseif width > 1
    %return ["vector", 2, [%<width>,1], "[0]"]
      %else
        %if (ei.StorageClass == "Auto") && ...
          (IsModelReferenceTarget() || (PassExtInpByRef(ei) && !SLibHasGlobalExternalInputsWithFPC()))
          %% scalars are passed via reference
      %return ["scalar", 2, [1,1], "[0]"]
        %else
          %return ["scalar", 2, [1,1], ""]
        %endif
      %endif
      %break
       
    %case "ExternalOutput"
      %assign eo = record
      %assign sysIdx = eo.Block[0]
      %assign blkIdx = eo.Block[1]
      %assign oblock = System[sysIdx].Block[blkIdx]
      %assign ip = oblock.DataInputPort
      %assign dims = LibGetRecordDimensions(ip)
      %assign nDims = SIZE(dims,1)
      %if nDims > 2
    %return ["%<matND>", %<nDims>, %<dims>, "[0]"]
      %elseif nDims == 2 && width > 1
    %assign nRows = dims[0]
    %assign nCols = dims[1]
    %return ["%<mat2D>", 2, [%<nRows>,%<nCols>], "[0]"]
      %elseif LibGetRecordWidth(ip) > 1
    %return ["vector", 2, [%<LibGetRecordWidth(ip)>,1], "[0]"]
      %else
      %return ["scalar", 2, [1,1], ""]
      %endif
      %break
       
    %case "MachineData"
       
      %assign sfInfo = record
      %assign sfSize = CAST("Number", sfInfo.Size)
       
      %if width > 1
    %return ["vector", 2, [%<width>,1], "[0]"]
      %else
    %return ["scalar", 2, [1,1], ""]
      %endif
      %%break
       
    %case "ZcSignalInfo"
      %if width > 1
        %return ["vector", 2, [%<width>,1], "[0]"]
      %else
        %return ["scalar", 2, [1,1], ""]
      %endif
 
    %default
      %<LibReportFatalError("unknown record type: %<record.RecordType>")>
  %endswitch
%endfunction
 
 
%%Function:SLibGetDataLayout=================================================
%%Abstract:
%%Foragivenrecord,returnavectorwiththefollowingformat
%%
%%["data-class",NumDimensions,[dim1,dim2,...,dimM],"optWidth"]
%function SLibGetDataLayout(record) void
  %return LibGetDataLayout(record)
%endfunction
 
 
%%Function:SLibIsBusVolatileCPP=================================================
%%Abstract:
%%Givenasignalrecord,returnstrueifthesignalisaBussignal,with
%%'volatile'customstorageclass,anditisgeneratingC++code.
%%
%function SLibIsBusVolatileCPP(record,msDefn)
  %return LibDataTypeIsBus(SLibGetRecordDataTypeId(record)) &&...
          msDefn.IsVolatile && ...
          ::GenCPP
%endfunction %% SLibIsBusVolatileCPP
 
%%Function:FcnIsCurrentRecordPreemptPrevRecord=================================
%%Abstract:
%%Determineifacurrentrecordcanpreemptanoldrecordunderthe
%%contextofdifferentsizesbufferreuse
%%TopTester:test/toolbox/rtw/targets/ert/model2model/pir2engine/tPir2EngineLutGecks04.m
%%TopTester:test/toolbox/simulink/variants/outputWhenUnconnected/tOutWhenUnconnected.m
%%
%function FcnIsCurrentRecordPreemptPrevRecord(currRecord, prevRecord) void
  %% root inport or output can preempt the declaration if:
  %% 1) Its size is no smaller than the previous one, OR
  %% 2) previous one is not root in/output
  %if (ISFIELD(currRecord, "IsAtRootInputOrOutput") && ...
    currRecord.IsAtRootInputOrOutput == TLC_TRUE)
    %if LibGetRecordWidth">LibGetRecordWidth(prevRecord) <= LibGetRecordWidth">LibGetRecordWidth(currRecord) || ...
      !ISFIELD(prevRecord, "IsAtRootInputOrOutput")
      %return TLC_TRUE
    %endif
  %% reusable csc can preempt the previous one if
  %% 1) It is NOT renamed, AND
  %% 2) previous one is not root in/output, AND
  %% 3) Its size is no smaller than previous' OR previous is renamed
  %elseif ((LibGetRecordWidth">LibGetRecordWidth(prevRecord) <= LibGetRecordWidth">LibGetRecordWidth(currRecord) || ...
    ISFIELD(prevRecord, "ReuseBufferName")) && ...
    !ISFIELD(currRecord, "ReuseBufferName") && ...
    !ISFIELD(prevRecord, "IsAtRootInputOrOutput"))
    %return TLC_TRUE
  %endif
  %return TLC_FALSE
%endfunction %% FcnIsCurrentRecordPreemptPrevRecord
 
%%Function:FcnAddCustomData==================================================
%%Abstract:
%%AddsacustomdatatoCustomData
%%TopTester:test/toolbox/simulink/variants/codevariants/tvss_code_variants.m
%%TopTester:test/toolbox/simulink/blocks/lib_LookupTables/LookupTable2D/rtw/tlookup2d.m
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%TopTester:test/toolbox/rtw/targets/AUTOSAR/Variants/dimensionVariants/tDimensionVariants5.m
%%TopTester:test/toolbox/simulink/variants/inlineVariants/variantSource/systemtests/tmFunctionCallSplitBlock_hidden_VC1.m
%%TopTester:test/toolbox/simulink/variants/vssSigObj/tVSSSigObj.m
%%
%function FcnAddCustomData(record) void
  %assign gmm = GlobalMemoryMap
   
  %% See if a custom class of the given name and package exists; if not,
  %% create it
  %assign packageName = LibGetRTWInfoObjectPackage(record)
  %assign className = LibGetCustomStorageClassName(record)
  %assign classIdx = SLibGetCustomStorageIdxInMap(packageName, className)
   
  %if classIdx == -1
     
    %% Get the CSC Definition - Used for data access
    %assign cscDefn = SLibGetCSCDefForName(packageName, className)
     
    %% Get Memory Section definition for the data
    %assign memSecName = cscDefn.MemorySection
    %assign msDefn = SLibGetMemorySectionDefForName(cscDefn.MSPackage, memSecName)
     
    %% Get Generate Type for class
    %assign genType = SLibGetGenerateTypeForName(packageName, className)
     
    %% Find record for this storage class and cache it
    %foreach idx = NumCustomStorageClasses
      %if (CustomStorageClass[idx].Package == packageName && ...
       CustomStorageClass[idx].Name == className)
    %addtorecord CustomStorageClass[idx] /
                 CSCDefaults { /
               CSCDefn cscDefn /
               MSDefn msDefn /
               GenType genType /
                 }
    %assign rtwRecord = CustomStorageClass[idx]
    %break
      %endif
    %endforeach
     
    %% Add record to global map
    %addtorecord gmm /
    CustomData { /
      Name className; /
      Package packageName; /
      NumData 0 ; /
      Version 1; /
      RTWRecord rtwRecord; /
      FullName "%<packageName>::%<className>"; /
      RecordType "CustomStorageClassInMap" /
      DataDefaults { /
        Access "direct" /
        Scope "global" /
    Class "scalar" /
    DataTypeIdx 0 /
    HasObject TLC_TRUE /
    IsComplex TLC_FALSE /
    IsFixedPoint TLC_FALSE /
    IsStruct TLC_FALSE /
    Permission "rw" /
        PPIf "" /
        PPEndIf "" /
    Type "parameter" /
      } /
    }
 
    %% Increment number of custom records
    %assign classIdx = gmm.NumCustomData
    %assign gmm.NumCustomData = gmm.NumCustomData + 1
     
    %% cache name and index away for fast retrival
    %if !ISFIELD(gmm.CustomDataIndexHash, packageName)
      %addtorecord gmm.CustomDataIndexHash %<packageName> {}
    %endif
    %addtorecord gmm.CustomDataIndexHash.%<packageName> %<className> classIdx
    %assign csc = gmm.CustomData[classIdx]
     
    %% Obtain version
    %assign dummyScope = csc
    %if GENERATE_TYPE_FUNCTION_EXISTS(dummyScope, "Version", genType)
      %assign csc.Version = GENERATE_TYPE(rtwRecord, "Version", genType)
    %endif
     
  %else
    %assign csc = gmm.CustomData[classIdx]
  %endif
 
  %% Cache CSCDefn in the record for faster access
  %assign cscDefn = csc.RTWRecord.CSCDefaults.CSCDefn
  %addtorecord record CSCDefn cscDefn
   
  %% Get Memory Section Defn associated with the custom data
  %assign msDefn = csc.RTWRecord.CSCDefaults.MSDefn
    %% Memory section can be instance specific
  %assign customAttrProps = LibGetCustomStorageAttributes(record)
  %assign msName = /
          LibGetInstanceSpecificProp(cscDefn, customAttrProps, "MemorySection")
  %if (msDefn.Name != msName)
    %assign msDefn = SLibGetMemorySectionDefForName(cscDefn.MSPackage, msName)
  %endif
   
  %% Cache Memory Section Definition in the record for faster access
  %addtorecord record MSDefn msDefn
   
  %% Cache Generate type in the record for faster access
  %addtorecord record GenerateType csc.RTWRecord.CSCDefaults.GenType
   
  %% Check if the record with the same name exists in the cscRecord
  %% For variant subsystems, we support signals with same name in
  %% mutually exclusive signal objects. Hence, we need to make
  %% sure that the key used in not the signal name.
  %% So we mangle the name, by appending the signal name with an "_"
  %% if it is already present in the csc record.
  %% Note that this is just a key and is used to add the custom
  %% storage class record to the gmm. We access this data
  %% in data_customdata.tlc using these mangled keys, but the
  %% record is printed out using the LibGetRecordIdentifier(dataRec)
  %% which prints the actual signal identifier
  %% TopTester : test/toolbox/simulink/variants/vssSigObj/tVSSSigObj.m testspec:vssSigObj_case1
  %assign cscDataNames = FIELDNAMES(csc.RTWRecord.Data)
  %assign numData = SIZE(cscDataNames)[1]
  %assign currRecordName = LibGetRecordIdentifier(record)
  %if numData > 0 && !SLibGetIsReusable(record)
      %%Check if name exists
      %foreach dataIdx = numData
          %assign dataName = cscDataNames[dataIdx]
          %if (dataName == currRecordName)
              %assign currRecordName = currRecordName + "_"
          %endif
      %endforeach
       
  %endif
  
  %% nestle data records in the parent storage class records
  %addtorecord csc.RTWRecord.Data %<currRecordName> record
  %assign prevRecord = csc.RTWRecord.Data.%<currRecordName>
   
  %if FcnIsCurrentRecordPreemptPrevRecord(record, prevRecord)
    %assign csc.RTWRecord.Data.%<currRecordName> = record
  %endif
 
  %% handle instance-specific storage class version
  %% cache custom storage class version in data
  %assign record.CustomStorageClassVersion = csc.Version
  %if record.CustomStorageClassVersion == -1
    %addtorecord record InstanceSpecificVersion TLC_TRUE
    %assign record.CustomStorageClassVersion = LibCustomData(record, "version", "", "")
  %endif
  %% Extract information that is common to all data records
  %assign name = LibGetRecordIdentifier(record)
  %assign dataTypeIdx = LibGetRecordDataTypeId(record)
  %assign isFixedPoint = DataTypes.DataType[dataTypeIdx].IsFixedPoint
  %assign isComplex = LibGetRecordIsComplex(record)
  %assign reim = isComplex ? ".%<tRealPart>" : ""
  %assign baseIndex = LibGetRecordWidth(record) == 1 ? "" : "[0]"
  %assign dataLayout = LibCustomData(record, "layout", "", "")
  %assign dataScope = SLibGetDataScope(record.CSCDefn, record)
  %assign dataAccess = SLibGetDataAccess(record.CSCDefn, record)
  %if (dataAccess == "Pointer")
    %assign baseAddr = "&(%<name>)"
  %else %% dataAccess is either direct or unknown
    %assign baseAddr = LibCustomData(record, "address", baseIndex, reim)
  %endif
 
  %switch record.RecordType
    %case "BlockOutput"
      %% block output signal
      %assign type = "signal"
      %assign permission = record.Invariant == "no" ? "rw" : "ro"
      %%
      %% add signal name to SignalInstanceCache so we make sure
      %% SL parameters and SF data don't clash
      %%
      %addtorecord gmm.ModelParameters.SignalInstanceCache %<name> record
      %break
     
    %case "ExternalInput"
    %case "ExternalOutput"
      %% Simulink external input/output signal (root inport/outport)
      %assign type = "signal"
      %assign permission = "rw"
      %%
      %% add signal name to SignalInstanceCache so we make sure
      %% SL parameters and SF data don't clash
      %%
      %addtorecord gmm.ModelParameters.SignalInstanceCache %<name> record
      %break
     
    %case "DWork"
      %% Simulink DWork (discrete states and persistent memory)
      %assign type = record.UsedAs == "DSTATE" ? "state" : "unknown"
      %assign permission = "ro"
      %%
      %% add signal name to SignalInstanceCache so we make sure
      %% SL parameters and SF data don't clash
      %%
      %addtorecord gmm.ModelParameters.SignalInstanceCache %<name> record
      %break
     
    %case "ModelParameter"
      %% Simulink parameter
      %assign type = "parameter"
      %assign permission = "rw"
      %break
       
    %case "ZcSignalInfo"
      %assign type = "signal"
      %assign permission = "rw"
      %break
    %case "MachineData"
       
      %<LibReportFatalError("custom storage class not supported for /
                             stateflow machine data")>
       
    %default
      %<LibReportFatalError("unknown record type: %<record.RecordType>")>
  %endswitch
 
  %if (msDefn.Name == "unknown")
    %% For R13 classes get qualifier from the TLC API
    %assign tq = LibCustomData(record, "qualifier", "", "")
  %else
    %if SLibIsBusVolatileCPP(record,msDefn)
      %assign errTxt = "Signal '%<record.SigLabel>' is a bus signal with " + ...
                       "'volatile' custom storage class. This is not " + ...
                       "supported when the target language " + ...
                       "is 'C++'. Consider removing the 'volatile' custom " + ...
                       "storage class, or changing the target language to " + ...
                       "'C', or avoiding using the bus."
      %<LibReportFatalError(errTxt)>
    %elseif (isComplex && msDefn.IsVolatile && GenCPP)
      %assign errTxt = "'%<name>' is complex with a 'volatile' " + ...
                       "custom storage class. This is not supported " + ...
                       "when the target language is 'C++'. " + ...
                       "Consider removing the 'volatile' custom storage " + ...
                       "class, or changing the target language to 'C', " + ...
                       "or avoiding using '%<name>'."
      %<LibReportFatalError(errTxt)>
    %endif
       
    %assign tq = SLibGetQualifier(msDefn)
  %endif
   
  %if !WHITE_SPACE(tq)
    %switch record.RecordType
      %case "BlockOutput"
      %case "ExternalInput"
      %case "ExternalOutput"
      %case "DWork"
      %case "ZcSignalInfo"
    %assign tqName = "StorageTypeQualifier"
    %break
      %case "ModelParameter"
    %assign tqName = "TypeQualifier"
    %break
      %case "MachineData"
    %<LibReportFatalError("custom storage class not supported for /
                           stateflow machine data")>
      %default
    %<LibReportFatalError("unknown record type: %<record.RecordType>")>
    %endswitch
    %<SETFIELD(record, tqName, tq)>
  %endif
     
  %assign class = dataLayout[0]
  %if class == "other"
    %assign nDims = -1
    %assign dims = []
  %else
    %assign nDims = dataLayout[1]
    %assign dims = dataLayout[2]
  %endif
   
  %% create custom data record
  %addtorecord csc /
  Data { /
    Name name; /
    BaseAddr baseAddr; /
    NumDimensions nDims /
  }
   
  %% Note: Some fields can be inherited from CustomData.DataDefaults
  %% If they cannot be inherited, set the fields explicitly
   
  %if SLibIsRecordSupportedForSymbolicDimensions(record) && ...
    LibRecordHasSymbolicWidth(record)
    %addtorecord csc.Data[csc.NumData] HasSymbolicDim TLC_TRUE
  %endif
   
  %% Check and add Access to the Data record
  %if dataAccess == "Pointer"
    %assign csc.Data[csc.NumData].Access = "indirect"
  %elseif (dataAccess == "unknown")
    %assign csc.Data[csc.NumData].Access = "unknown"
  %endif
   
  %% Check and add Scope to the Data record
  %assign resolvedScope = FcnVerifyDataScope(record, dataScope)
  %assign csc.Data[csc.NumData].Scope = resolvedScope[0]
   
  %% Check and add Class to the Data record
  %if class != "scalar"
    %assign csc.Data[csc.NumData].Class = class
  %endif
     
  %% Check and add DataTypeIdx to the Data record
  %if dataTypeIdx > 0
    %assign csc.Data[csc.NumData].DataTypeIdx = dataTypeIdx
  %endif
    
  %% Check and add IsComplex to the Data record
  %if isComplex
    %assign csc.Data[csc.NumData].IsComplex = isComplex
  %endif
   
  %% Check and add IsFixedPoint to the Data record
  %if isFixedPoint
    %assign csc.Data[csc.NumData].IsFixedPoint = isFixedPoint
    %% Add FixedPoint record
    %<FcnAddFixedPointInfo(csc.Data[csc.NumData], record)>
  %endif
   
  %% Check and add Permission to the Data record
  %if permission != "rw"
    %assign csc.Data[csc.NumData].Permission = permission
  %endif
   
  %% Check and add Type to the Data record
  %if type != "parameter"
    %assign csc.Data[csc.NumData].Type = type
  %endif
   
  %% Add NumDimensions, NumRows NumCols
  %if nDims > 2
    %addtorecord csc.Data[csc.NumData] Dimensions dims
  %elseif nDims > 0
    %addtorecord csc.Data[csc.NumData] NumRows CAST("Number", dims[0])
    %addtorecord csc.Data[csc.NumData] NumCols CAST("Number", dims[1])
  %endif
   
  %% Add preprocessor stuff
  %assign vcRecord = SLibGetDataInlineVariantNetConditions(record)
  %if !WHITE_SPACE(vcRecord.ifCond)
    %addtorecord csc.Data[csc.NumData] PPIf vcRecord.ifCond
    %addtorecord csc.Data[csc.NumData] PPEndIf vcRecord.endIfCond
  %endif
   
  %if ISFIELD(record,"isActiveDuringCodegen")
        %addtorecord csc.Data[csc.NumData] isActiveDuringCodegen record.isActiveDuringCodegen
  %endif
 
  %if ISFIELD(record, "HasStructCSCElement")
        %addtorecord csc.Data[csc.NumData] HasStructCSCElement record.HasStructCSCElement
  %endif
  %%
  %% Parameter specific fields.
  %% (Note: SL_LogicalSrc and SL_ExtModeType are for internal use only)
  %%
  %if record.RecordType == "ModelParameter"
    %assign idNum = IDNUM(record.LogicalSrc)
    %addtorecord csc.Data[csc.NumData] Value SLibGetValueFromParamRec(record, TLC_FALSE)
    %addtorecord csc.Data[csc.NumData] IsTransformed 0
    %addtorecord csc.Data[csc.NumData] SL_LogicalSrc idNum[1]
    %addtorecord csc.Data[csc.NumData] SL_ExtModeType "parameter"
  %endif
 
  %%
  %% Signal specific fields.
  %% (Note: SL_LogicalSrc and SL_ExtModeType are for internal use only)
  %%
  %if record.RecordType == "BlockOutput"
    %assign idNum = IDNUM(record.LogicalSrc)
    %addtorecord csc.Data[csc.NumData] SL_LogicalSrc idNum[1]
    %addtorecord csc.Data[csc.NumData] SL_ExtModeType "signal"
  %endif
   
  %%
  %% DWork specific fields.
  %% (Note: SL_LogicalSrc and SL_ExtModeType are for internal use only)
  %%
  %if record.RecordType == "DWork"
    %assign idNum = IDNUM(record.LogicalSrc)
    %addtorecord csc.Data[csc.NumData] SL_LogicalSrc idNum[1]
    %addtorecord csc.Data[csc.NumData] SL_ExtModeType "dwork"
  %endif
   
  %%
  %% External Input signal specific fields.
  %% (Note: SL_ExtModeType is for internal use only)
  %%
  %if record.RecordType == "ExternalInput"
    %addtorecord csc.Data[csc.NumData] SL_ExtModeType "signal"
  %endif
  %%
  %% External Output signal specific fields.
  %% (Note: SL_ExtModeType is for internal use only)
  %%
  %if record.RecordType == "ExternalOutput"
    %addtorecord csc.Data[csc.NumData] SL_ExtModeType "signal"
  %endif
   
  %% optional Simulink data object properties
  %if record.HasObject
    %addtorecord csc.Data[csc.NumData] Object record.Object
  %else
    %assign csc.Data[csc.NumData].HasObject = TLC_FALSE
  %endif
   
  %% optional Bus Object Properties
  %<FcnAddBusStructure(csc.Data[csc.NumData], dataTypeIdx)>
 
  %% Cross Reference the record in the map entry
  %addtorecord csc.Data[csc.NumData] RTWRecord record
   
  %% add custom data record to map
  %assign csc.NumData = csc.NumData + 1
   
  %% return data index
  %return csc.NumData-1
%endfunction
 
%%Function:FcnAddUnstructuredData============================================
%%Abstract:
%%Addsanunstructured(global)datatoUnstructuredData.
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants9.m
%%TopTester:test/toolbox/simulink/blocks/lib_MathOperations/Product/rtw/tProductBlk_Codegencheck_MdlRefSim_Target.m
%%
%function FcnAddUnstructuredData(record) void
  %assign gmm = GlobalMemoryMap
  %assign usd = gmm.UnstructuredData
   
  %assign isDefinedDefault = usd.DataDefaults.IsDefined
  %assign isDefined = isDefinedDefault
 
  %if SLibIsCoderGroupUseAccessFcnForDataRecord(record) && record.RecordType == "ModelParameter"
    %return usd.NumData
  %endif
   
  %switch record.RecordType
    %case "BlockOutput"
 
      %% block output signal
      %assign bo = record
      %assign dataTypeIdx = LibGetRecordDataTypeId(bo)
      %assign isComplex = LibGetRecordIsComplex(bo)
      %assign isFixedPoint = DataTypes.DataType[dataTypeIdx].IsFixedPoint
      %assign dataLayout = SLibGetDataLayout(bo)
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign name = LibGetRecordIdentifier(bo)
      %assign isPointer = bo.StorageClass == "ImportedExternPointer" ? ...
    TLC_TRUE : TLC_FALSE
      %if (isPointer)
    %assign baseAddr = "&(%<name>)"
      %else
    %assign baseAddr = "&%<name>%%<reim>"
      %endif
      %%
      %assign isDefined = ISEQUAL(bo.StorageClass, "ExportedGlobal") && ...
        ISEQUAL(bo.DrivesModelRefRootOutport, "no")
      %%
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %if SLibGetArgIsVarDims(bo)
        %% Var-Dims input signal
        %if SLibGetArgUseCanDimSizeDW(bo)
          %assign baseSysIdx = GetBaseSystemIdx()
          %assign cdwIdx = SLibGetCanDimSizeDWIdxForArg(bo)
          %assign canDWork = System[baseSysIdx].Interface.CanonicalDWorkArgDef[cdwIdx]
          %assign vardimsBaseAddr = "&%<LibGetRecordIdentifier(canDWork)>[0]"
          %assign vardimsKey = "CANDW%<cdwIdx>"
        %else
          %assign vardimsBaseAddr = "%<SLibGetDimSizeDWorkFullPath(bo.DimSizeDWork)>"
          %assign vardimsKey = "DIMDW%<bo.DimSizeDWork>"
        %endif
      %endif
      %assign type = "signal"
      %assign permission = bo.Invariant == "no" ? "rw" : "ro"
      %%
      %% add signal name to SignalInstanceCache so we make sure
      %% SL parameters and SF data don't clash
      %%
      %addtorecord gmm.ModelParameters.SignalInstanceCache %<name> bo
      %break
     
    %case "ExternalInput"
       
      %% Simulink external input signal (root inport)
       
      %assign ei = record
      %assign dataTypeIdx = LibGetRecordDataTypeId(ei)
      %assign isComplex = LibGetRecordIsComplex(ei)
      %assign isFixedPoint = DataTypes.DataType[dataTypeIdx].IsFixedPoint
      %assign dataLayout = SLibGetDataLayout(ei)
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign name = LibGetRecordIdentifier(ei)
      %if (MultiInstanceERTCode && (ei.StorageClass == "Auto"))
        %% rtU_ is added in case of multiinstance ert code and auto signals
        %assign name = "%<LibGetExternalInputStruct()>%<UQualifier>%<name>"
        %assign isDefined = TLC_FALSE
      %endif
      %assign isPointer = ei.StorageClass == "ImportedExternPointer" ? ...
    TLC_TRUE : TLC_FALSE
      %if (isPointer)
    %assign baseAddr = "&(%<name>)"
      %else
    %assign baseAddr = "&%<name>%%<reim>"
      %endif
      %assign isDefined = isDefined && ISEQUAL(ei.StorageClass, "ExportedGlobal")
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %if SLibGetExternalIOIsVarDims(ei)
        %% Var-Dims input signal
        %assign baseSysIdx = GetBaseSystemIdx()
        %assign cdwIdx = SLibGetCanDimSizeDWIdxForArg(ei)
        %assign canDWork = System[baseSysIdx].Interface.CanonicalDWorkArgDef[cdwIdx]
        %assign vardimsBaseAddr = "&%<LibGetRecordIdentifier(canDWork)>[0]"
        %assign vardimsKey = "CANDW%<cdwIdx>"
      %endif
      %assign type = "signal"
      %assign permission = "rw"
      %%
      %% add signal name to SignalInstanceCache so we make sure
      %% SL parameters and SF data don't clash
      %%
      %addtorecord gmm.ModelParameters.SignalInstanceCache %<LibGetRecordIdentifier(ei)> ei
      %break
     
    %case "ExternalOutput"
      %% Simulink external output signal (root outport)
 
      %assign eo = record
      %assign dataTypeIdx = LibGetRecordDataTypeId(eo)
      %assign isComplex = LibGetRecordIsComplex(eo)
      %assign isFixedPoint = DataTypes.DataType[dataTypeIdx].IsFixedPoint
      %assign dataLayout = SLibGetDataLayout(eo)
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign name = LibGetRecordIdentifier(eo)
      %assign isPointer = eo.StorageClass == "ImportedExternPointer" ? ...
    TLC_TRUE : TLC_FALSE
      %if (isPointer)
    %assign baseAddr = "&(%<name>)"
      %else
    %assign baseAddr = "&%<name>%%<reim>"
      %endif
      %assign isDefined = isDefined && ISEQUAL(eo.StorageClass, "ExportedGlobal")
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %assign type = "signal"
      %assign permission = "rw"
      %%
      %% add signal name to SignalInstanceCache so we make sure
      %% SL parameters and SF data don't clash
      %addtorecord gmm.ModelParameters.SignalInstanceCache %<LibGetRecordIdentifier(eo)> eo
      %break
 
    %case "DWork"
       
      %% Simulink external input signal (root inport)
       
      %assign dwRec = record
      %assign dataTypeIdx = SLibDWorkDataTypeId(dwRec)
      %assign isComplex = SLibDWorkIsComplex(dwRec)
      %assign isFixedPoint = DataTypes.DataType[dataTypeIdx].IsFixedPoint
      %assign dataLayout = SLibGetDataLayout(dwRec)
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign name = LibGetRecordIdentifier(dwRec)
      %assign isPointer = dwRec.StorageClass == "ImportedExternPointer" ? ...
    TLC_TRUE : TLC_FALSE
      %if (isPointer)
    %assign baseAddr = "&(%<name>)"
      %else
    %assign baseAddr = "&%<name>%%<reim>"
      %endif
      %assign isDefined = (ISEQUAL(dwRec.StorageClass, "ExportedGlobal") && ...
        ( (isDefined && ISEQUAL(dwRec.UsedAs, "DWORK")) || ...
        ISEQUAL(dwRec.UsedAs, "DSTATE") ) )
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %assign type = dwRec.UsedAs == "DSTATE" ? "state" : "unknown"
      %assign permission = "ro"
      %%
      %% add signal name to SignalInstanceCache so we make sure
      %% SL parameters and SF data don't clash
      %%
      %addtorecord gmm.ModelParameters.SignalInstanceCache %<name> dwRec
      %break
     
    %case "ModelParameter"
       
      %% Simulink parameter
       
      %assign mdlParam = record
      %assign dataTypeIdx = LibGetRecordDataTypeId(mdlParam)
      %assign isComplex = LibGetRecordIsComplex(mdlParam)
      %assign isFixedPoint = DataTypes.DataType[dataTypeIdx].IsFixedPoint
      %assign name = LibGetRecordIdentifier(mdlParam)
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign dataLayout = SLibGetDataLayout(mdlParam)
      %assign isPointer = mdlParam.StorageClass == "ImportedExternPointer" ? ...
    TLC_TRUE : TLC_FALSE
      %assign isDefined = isDefined && ...
        ISEQUAL(mdlParam.StorageClass, "ExportedGlobal")
      %if (isPointer)
    %assign baseAddr = "&(%<name>)"
      %else
    %assign baseAddr = LibModelParameterAddr(mdlParam,"","",0)
      %endif
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %assign type = "parameter"
      %assign permission = "rw"
      %break
       
    %case "MachineData"
       
      %% Stateflow data
       
      %assign sfInfo = record
      %assign dataTypeIdx = SLibGetIdFromMLDataType(sfInfo.DataType)
      %assign isFixedPoint = 0
      %assign name = sfInfo.Name
      %assign isComplex = 0
      %assign reim = ""
      %assign dataLayout = SLibGetDataLayout(sfInfo)
      %assign baseAddr = "&%<name>%%<reim>"
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %assign type = "data"
      %assign isPointer = TLC_FALSE
      %assign access = "direct"
      %assign permission = "rw"
      %assign isDefined = ISEQUAL(sfInfo.Scope, "Exported")
      %break
       
    %default
      %<LibReportFatalError("unknown record type: %<record.RecordType>")>
  %endswitch
 
  %assign class = dataLayout[0]
  %assign nDims = dataLayout[1]
  %assign dims = dataLayout[2]
   
  %% create unstructured data record
  %addtorecord usd /
  Data { /
    Name name /
    BaseAddr baseAddr /
  }
   
  %% Note: Some fields can be inherited from UnstructureData.DataDefaults
  %% If they cannot be inherited, set the fields explicitly
   
  %% Check and add Access to the Data record
  %if (isPointer)
    %assign usd.Data[usd.NumData].Access = "indirect"
  %endif
   
  %% Check and add class to the Data record
  %if class != "scalar"
    %assign usd.Data[usd.NumData].Class = class
  %endif
   
  %% Check and add DataTypeIdx to the Data record
  %if dataTypeIdx > 0
    %assign usd.Data[usd.NumData].DataTypeIdx = dataTypeIdx
  %endif
   
  %% Check and add IsComplex to the Data record
  %if isComplex
    %assign usd.Data[usd.NumData].IsComplex = isComplex
  %endif
   
  %% Check and add IsFixedPoint to the Data record
  %if isFixedPoint
    %assign usd.Data[usd.NumData].IsFixedPoint = isFixedPoint
    %% Add FixedPoint record
    %<FcnAddFixedPointInfo(usd.Data[usd.NumData], record)>
  %endif
   
  %% Check and add IsDefined to the Data record
  %if (isDefinedDefault != isDefined)
    %assign usd.Data[usd.NumData].IsDefined = isDefined
  %endif
   
  %% Check and add vardimsBaseAddr to the Data record
  %if vardimsBaseAddr != SLibGetNullDefinitionFromTfl()
    %addtorecord usd.Data[usd.NumData] IsVarDims TLC_TRUE
    %addtorecord usd.Data[usd.NumData] VarDimsBaseAddr vardimsBaseAddr
    %addtorecord usd.Data[usd.NumData] VarDimsKey vardimsKey
  %else
    %addtorecord usd.Data[usd.NumData] IsVarDims TLC_FALSE
  %endif
   
  %if SLibIsRecordSupportedForSymbolicDimensions(record) && ...
    LibRecordHasSymbolicWidth(record)
    %addtorecord usd.Data[usd.NumData] HasSymbolicDim TLC_TRUE
  %endif
   
  %% Check and add Dimensions to the Data record
  %if nDims > 2
    %addtorecord usd.Data[usd.NumData] Dimensions dims
    %assign usd.Data[usd.NumData].NumDimensions = nDims
  %else
    %if dims[0] > 1
      %assign usd.Data[usd.NumData].NumRows = CAST("Number", dims[0])
    %endif
    %if dims[1] > 1
      %assign usd.Data[usd.NumData].NumCols = CAST("Number", dims[1])
    %endif
  %endif
   
  %% Check and add permission to the Data record
  %if permission != "rw"
    %assign usd.Data[usd.NumData].Permission = permission
  %endif
   
  %% Check and add Type to the Data record
  %if type != "parameter"
    %assign usd.Data[usd.NumData].Type = type
  %endif
 
  %% Add preprocessor stuff
  %assign vcRecord = SLibGetDataInlineVariantNetConditions(record)
  %if !WHITE_SPACE(vcRecord.ifCond)
    %addtorecord usd.Data[usd.NumData] PPIf vcRecord.ifCond
    %addtorecord usd.Data[usd.NumData] PPEndIf vcRecord.endIfCond
  %endif
   
  
  %%
  %% Parameter specific fields.
  %% (Note: SL_LogicalSrc and SL_ExtModeType are for internal use only)
  %%
  %if record.RecordType == "ModelParameter"
    %assign idNum = IDNUM(mdlParam.LogicalSrc)
    %addtorecord usd.Data[usd.NumData] Value SLibGetValueFromParamRec(mdlParam, TLC_FALSE)
    %addtorecord usd.Data[usd.NumData] IsTransformed 0
    %addtorecord usd.Data[usd.NumData] SL_LogicalSrc idNum[1]
    %addtorecord usd.Data[usd.NumData] SL_ExtModeType "parameter"
  %endif
 
  %%
  %% Signal specific fields.
  %% (Note: SL_LogicalSrc and SL_ExtModeType are for internal use only)
  %%
  %if record.RecordType == "BlockOutput"
    %assign idNum = IDNUM(bo.LogicalSrc)
    %addtorecord usd.Data[usd.NumData] SL_LogicalSrc idNum[1]
    %addtorecord usd.Data[usd.NumData] SL_ExtModeType "signal"
  %endif
   
  %%
  %% DWork specific fields.
  %% (Note: SL_LogicalSrc and SL_ExtModeType are for internal use only)
  %%
  %if record.RecordType == "DWork"
    %assign idNum = IDNUM(dwRec.LogicalSrc)
    %addtorecord usd.Data[usd.NumData] SL_LogicalSrc idNum[1]
    %addtorecord usd.Data[usd.NumData] SL_ExtModeType "dwork"
  %endif
   
  %%
  %% External Input signal specific fields.
  %% (Note: SL_ExtModeType is for internal use only)
  %%
  %if record.RecordType == "ExternalInput"
    %addtorecord usd.Data[usd.NumData] SL_ExtModeType "signal"
  %endif
   
  %if record.RecordType == "ExternalOutput"
    %addtorecord usd.Data[usd.NumData] SL_ExtModeType "signal"
  %endif
   
  %%
  %% Machine data specific fields.
  %% (Note: SL_ExtModeType is for internal use only)
  %%
  %if record.RecordType == "MachineData"
    %addtorecord usd.Data[usd.NumData] SL_ExtModeType "machineData"
  %endif
   
  %% optional Simulink data object properties
  %<FcnAddObjectProperties(usd.Data[usd.NumData], record)>
   
  %% optional Bus Object Properties
  %<FcnAddBusStructure(usd.Data[usd.NumData], dataTypeIdx)>
 
  %% compute size of data
  %assign size = FcnComputeSizeFromDims(dims,isComplex)
 
  %% add unstructured data record to map
  %assign usd.NumData = usd.NumData + 1
  %assign usd.NumTotalElements = usd.NumTotalElements + size
   
  %% return data index
  %return usd.NumData-1
%endfunction
 
 
%%Function:FcnAddStructuredData==============================================
%%Abstract:
%%AddDatarecordtodesignated(structured)section.
%%TopTester:test/toolbox/simulink/variants/string/tStringSupport.m
%%TopTester:test/toolbox/simulink/blocks/tmux_blkDialog.m
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants3.m
%%TopTester:test/toolbox/simulink/blocks/tmux_blkDialog.m
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%TopTester:test/toolbox/fixpoint/fixpt_autoscale/MLFB/apply_workflow/t_edit_operations2.m
%%
%function FcnAddStructuredData(structure, section, record) void
  %switch record.RecordType
    %case "BlockOutput"
 
      %% block output signal
 
      %assign bo = record
      %assign dataTypeIdx = LibGetRecordDataTypeId(bo)
      %assign isComplex = LibGetRecordIsComplex(bo)
      %assign isFixedPoint = DataTypes.DataType[dataTypeIdx].IsFixedPoint
      %assign dataLayout = SLibGetDataLayout(bo)
      %assign isInvariant = bo.Invariant == "yes"
      %assign baseSysIdx = GetBaseSystemIdx()
      %assign name = ...
          SLibGetBlockOutputIdentifierFromRecord(bo, baseSysIdx)
 
      %assign type = "signal"
      %assign permission = isInvariant ? "ro" : "rw"
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %if SLibGetArgIsVarDims(bo)
        %% Var-Dims input signal
        %if SLibGetArgUseCanDimSizeDW(bo)
          %assign cdwIdx = SLibGetCanDimSizeDWIdxForArg(bo)
          %assign canDWork = System[bo.SysNum-1].Interface.CanonicalDWorkArgDef[cdwIdx]
          %assign vardimsBaseAddr = "&%<LibGetRecordIdentifier(canDWork)>[0]"
          %assign vardimsKey = "CANDW%<cdwIdx>"
        %else
          %assign vardimsName = "%<SLibGetBlockOutputVarDimsIdentifierFromRecord(bo.DimSizeDWork, baseSysIdx)>"
          %assign dworkRec = ::CompiledModel.DWorks.DWork[bo.DimSizeDWork]
          %assign vardimsLayout = SLibGetDataLayout(dworkRec)
          %assign vardimsBaseAddr = "&%<vardimsName>%"
          %assign vardimsKey = "DIMDW%<bo.DimSizeDWork>"
        %endif
      %endif
 
      %break
     
    %case "ExternalInput"
       
      %% external input signal (root inport)
 
      %assign ei = record
      %assign dataTypeIdx = LibGetRecordDataTypeId(ei)
      %assign isComplex = LibGetRecordIsComplex(ei)
      %assign isFixedPoint = DataTypes.DataType[dataTypeIdx].IsFixedPoint
      %assign dataLayout = SLibGetDataLayout(ei)
      %assign name = FcnGetVarGroupElementPathFromRecord(ei)
      %assign type = "signal"
      %assign permission = "rw"
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %if SLibGetExternalIOIsVarDims(ei)
        %% Var-Dims input signal
        %assign baseSysIdx = GetBaseSystemIdx()
        %assign cdwIdx = SLibGetCanDimSizeDWIdxForArg(arg)
        %assign canDWork = System[baseSysIdx].Interface.CanonicalDWorkArgDef[cdwIdx]
        %assign vardimsBaseAddr = "&%<LibGetRecordIdentifier(canDWork)>[0]"
        %assign vardimsKey = "CANDW%<cdwIdx>"
      %endif
 
      %break
     
    %case "ExternalOutput"
       
      %% external output signal (root outport)
       
      %assign eo = record
      %assign sysIdx = eo.Block[0]
      %assign blkIdx = eo.Block[1]
      %assign oblock = System[sysIdx].Block[blkIdx]
      %assign ip = oblock.DataInputPort
      %assign dataTypeIdx = LibGetRecordDataTypeId(ip)
      %assign isComplex = LibGetRecordIsComplex(ip)
      %assign isFixedPoint = 0
      %assign dataLayout = SLibGetDataLayout(eo)
      %assign name = FcnGetVarGroupElementPathFromRecord(eo)
      %assign type = "signal"
      %assign permission = "ro"
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %if ISFIELD(eo, "HasVarDims") && (eo.HasVarDims == 1) && ISFIELD(eo, "SizeVarGroupIdx")
        %% Var-Dims Output signal
 
        %assign varGroupMemberType = SLibVarGroupElementType(eo.SizeVarGroupIdx[0], eo.SizeVarGroupIdx[1])
        %assign varGroupMemberTypeName = LibCGTypeName(varGroupMemberType)
        %if varGroupMemberTypeName != "int32_T"
          %assign errTxt = "Unhandled condition for C API Root IO: ExternalOutput is a bus object that contains variable dimension elements"
          %<LibReportError(errTxt)>
        %endif
        %assign baseSysIdx = GetBaseSystemIdx()
        %assign vardimsName = "%<SLibGetExternalOutputVarDimsIdentifierFromRecord(eo.SizeVarGroupIdx, baseSysIdx)>"
        %assign vardimsBaseAddr = "&%<vardimsName>"
        %assign vardimsKey = "VG%"
      %endif
       
      %break
     
    %case "ModelParameter"
       
      %% Simulink parameter
       
      %assign mdlParam = record
      %assign idNum = IDNUM(mdlParam.LogicalSrc)
      %assign mdlParamIdx = idNum[1]
      %assign dataTypeIdx = LibGetRecordDataTypeId(mdlParam)
      %assign isComplex = LibGetRecordIsComplex(mdlParam)
      %assign isFixedPoint = DataTypes.DataType[dataTypeIdx].IsFixedPoint
      %assign dataLayout = SLibGetDataLayout(mdlParam)
      %if ISFIELD(mdlParam, "InstanceSpecific") && mdlParam.InstanceSpecific && !ISFIELD(mdlParam, "VarGroupIdx")
        %assign name = SLibGetGroupedParamQualifiedIdentifier(mdlParam)
      %else
        %assign name = FcnGetAutoParamIdentifier(mdlParam)
      %endif
      %assign type = "parameter"
 
      %if mdlParam.IsSfcnSizePrm || ...
    mdlParamIdx >= NumInrtP
    %% Parameter is a
    %% o C-MEX S-Function size parameter
    %% o Rolled vector or matrix
    %assign permission = "ro"
      %else
    %assign permission = "rw"
      %endif
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
       
      %% the guaridng for states and parameters is handled in different ways
      %assign vcRecord = SLibGetDataInlineVariantNetConditions(record)
 
      %break
       
    %case "DWork"
       
      %% DWork (states in paticular)
       
      %assign dwRec = record
      %assign dataTypeIdx = SLibDWorkDataTypeId(dwRec)
      %assign isComplex = SLibDWorkIsComplex(dwRec)
      %assign isFixedPoint = DataTypes.DataType[dataTypeIdx].IsFixedPoint
      %assign dataLayout = SLibGetDataLayout(dwRec)
      %assign baseSysIdx = GetBaseSystemIdx()
      %assign name = FcnGetDWorkIdentifier(dwRec, baseSysIdx)
      %assign type = dwRec.UsedAs == "DSTATE" ? "state" : "unknown"
      %assign permission = "ro"
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %break
       
    %case "ChartData"
       
      %% Stateflow local chart data
       
      %assign chartData = record
      %assign dataTypeIdx = chartData.DataTypeIdx
      %assign isComplex = chartData.IsComplex
      %assign isFixedPoint = 0
      %assign dataLayout = SLibGetDataLayout(chartData)
      %assign baseSysIdx = GetBaseSystemIdx()
      %assign dwRec = chartData.DWork
      %assign dwid = FcnGetDWorkIdentifier(dwRec, baseSysIdx)
      %assign name = dwid + "." + chartData.Name
      %assign type = "unknown"
      %assign permission = "ro"
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
       
      %break
       
    %case "ContState"
       
      %% Continuous states
       
      %assign cStateRec = record
      %assign dataTypeIdx = 0
      %assign isComplex = 0
      %assign isFixedPoint = 0
      %assign dataLayout = SLibGetDataLayout(cStateRec)
      %assign baseSysIdx = GetBaseSystemIdx()
      %assign name = FcnGetCStateIdentifier(cStateRec, baseSysIdx)
      %assign type = "state"
      %assign permission = "ro"
      %assign vardimsBaseAddr = SLibGetNullDefinitionFromTfl()
      %break
       
    %default
      %<LibReportFatalError("unknown section type.")>
  %endswitch
 
  %assign class = dataLayout[0]
  %assign nDims = dataLayout[1]
  %assign dims = dataLayout[2]
 
  %assign reim = isComplex ? ".%<tRealPart>" : ""
   
  %if SLibIsContainerCGTypeND(record)
    %% Insert an nD reference to the first element if a flat index is
    %% used on an nD variable
    %assign recNumDims = LibCGTypeNumDimensions(SLibGetRecordContainerCGTypeIdx(record))
    %assign id = LibGetAddressOfFirstElement(name, recNumDims)
    %assign baseAddr = "&%<id>%%<reim>"
  %else
    %assign baseAddr = "&%<name>%%<reim>"
  %endif
   
  %if (structure.Name == "StateDerivatives")
    %assign name = "%<RTMGet("dX")>[%<section.OffsetCounter>]"
    %assign baseAddr = "&(%<name>)"
    %assign type = "stateDerivative"
  %endif
   
  %with structure %% TLC DataDefaults requirement, grandchild inheritance
     
    %% create a structured data record
    %addtorecord section /
    Data { /
      Name name; /
      BaseAddr baseAddr; /
      OffsetFromBaseAddr section.OffsetCounter /
    }
     
    %% Note: Some fields can be inherited from StructuredData.DataDefaults
    %% If they cannot be inherited, set the fields explicitly
     
    %% Check and add class to the Data record
    %if class != "scalar"
      %assign section.Data[section.NumData].Class = class
    %endif
     
    %% Check and add Fixed Point to the the data record
    %if isFixedPoint
      %assign section.Data[section.NumData].IsFixedPoint = TLC_TRUE
      %% Add FixedPoint record
      %<FcnAddFixedPointInfo(section.Data[section.NumData], record)>
    %endif
     
    %% Check and add vardimsBaseAddr to the data record
    %if vardimsBaseAddr != SLibGetNullDefinitionFromTfl()
      %addtorecord section.Data[section.NumData] IsVarDims TLC_TRUE
      %addtorecord section.Data[section.NumData] VarDimsBaseAddr vardimsBaseAddr
      %addtorecord section.Data[section.NumData] VarDimsKey vardimsKey
    %else
      %addtorecord section.Data[section.NumData] IsVarDims TLC_FALSE
    %endif
   
    %if SLibIsRecordSupportedForSymbolicDimensions(record) && ...
      LibRecordHasSymbolicWidth(record)
      %addtorecord section.Data[section.NumData] HasSymbolicDim TLC_TRUE
    %endif
     
    %% Check and add Dimensions to the Data record
    %if nDims > 2
      %addtorecord section.Data[section.NumData] Dimensions dims
      %assign section.Data[section.NumData].NumDimensions = nDims
    %else
      %if dims[0] > 1
    %assign section.Data[section.NumData].NumRows = CAST("Number", dims[0])
      %endif
      %if dims[1] > 1
    %assign section.Data[section.NumData].NumCols = CAST("Number", dims[1])
      %endif
    %endif
     
    %% Check and add Permission to the Data record
    %if permission != "rw"
      %assign section.Data[section.NumData].Permission = permission
    %endif
 
    %% Check and add Type to the Data record
    %if type != structure.DataDefaults.Type
      %assign section.Data[section.NumData].Type = type
    %endif
 
    %% Add preprocessor stuff
   %if record.RecordType == "ModelParameter"
     %if !WHITE_SPACE(vcRecord.ifCond)
       %addtorecord section.Data[section.NumData] PPIf vcRecord.ifCond
       %addtorecord section.Data[section.NumData] PPEndIf vcRecord.endIfCond
     %endif
   %else
     %assign vcRecord = SLibGetDataInlineVariantNetConditions(record)
     %if !WHITE_SPACE(vcRecord.ifCond)
       %addtorecord section.Data[section.NumData] PPIf vcRecord.ifCond
       %addtorecord section.Data[section.NumData] PPEndIf vcRecord.endIfCond
     %endif
   %endif
     
    %%
    %% Parameter specific fields.
    %% (Note: SL_LogicalSrc and SL_ExtModeType are for internal use only)
    %%
    %if record.RecordType == "ModelParameter"
      %assign idNum = IDNUM(mdlParam.LogicalSrc)
      %addtorecord section.Data[section.NumData] Value SLibGetValueFromParamRec(mdlParam, TLC_FALSE)
      %addtorecord section.Data[section.NumData] IsTransformed mdlParam.Transformed
      %addtorecord section.Data[section.NumData] SL_LogicalSrc idNum[1]
      %addtorecord section.Data[section.NumData] SL_ExtModeType "parameter"
    %endif
     
    %%
    %% Signal specific fields.
    %% (Note: SL_LogicalSrc and SL_ExtModeType are for internal use only)
    %%
    %if record.RecordType == "BlockOutput"
      %assign idNum = IDNUM(bo.LogicalSrc)
      %addtorecord section.Data[section.NumData] SL_LogicalSrc idNum[1]
      %addtorecord section.Data[section.NumData] SL_ExtModeType "signal"
    %endif
     
    %%
    %% DWork specific fields.
    %% (Note: SL_LogicalSrc and SL_ExtModeType are for internal use only)
    %%
    %if record.RecordType == "DWork"
      %assign idNum = IDNUM(dwRec.LogicalSrc)
      %addtorecord section.Data[section.NumData] SL_LogicalSrc idNum[1]
      %addtorecord section.Data[section.NumData] SL_ExtModeType "dwork"
    %endif
     
    %%
    %% External Input signal specific fields.
    %% (Note: SL_ExtModeType is for internal use only)
    %%
    %if record.RecordType == "ExternalInput"
      %addtorecord section.Data[section.NumData] SL_ExtModeType "signal"
    %endif
     
    %% Simulink data object properties
    %<FcnAddObjectProperties(section.Data[section.NumData], record)>
     
    %% optional Bus Object Properties
    %<FcnAddBusStructure(section.Data[section.NumData], section.DataTypeIdx)>
   
    %% compute size of data
    %assign size = FcnComputeSizeFromDims(dims,isComplex)
     
    %% add structured data record
    %assign section.NumData = section.NumData + 1
    %assign section.NumElements = section.NumElements + size
    %assign structure.NumTotalElements = structure.NumTotalElements + size
     
    %% Adjust offset for string data type
    %if LibIsStringDataType(dataTypeIdx)
      %% For offset calculation, treat string data as scalar
      %assign section.OffsetCounter = section.OffsetCounter + 1
    %else
      %assign section.OffsetCounter = section.OffsetCounter + size
    %endif
     
  %endwith %%endwith structure
   
  %% return data index
  %return section.NumData-1
%endfunction
 
%%Toptetser:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function FcnGetVarGroupElementPathFromRecord(record) void
  %assign varGroup = ::CompiledModel.VarGroups.VarGroup[record.VarGroupIdx[0]]
  %assign elementpath = SLibCG_GetVarGroupElementPath(record.VarGroupIdx, varGroup.SysIdx, System[varGroup.SysIdx].CrossNoArgFcnBound)
  %return elementpath
%endfunction
   
%%Function:FcnAddSection=====================================================
%%Abstract:
%%Addasectiontoastructure.
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%TopTester:test/toolbox/simulink/blocks/lib_SignalAttributes/InitialCondition/rtw/tinitcond.m
%%
%function FcnAddSection(structure, record) void
  %%
  %% core attributes
  %%
  %switch record.RecordType
    %case "BlockOutput"
      %% signal
      %assign bo = record
      %assign dataTypeIdx = LibGetRecordDataTypeId(bo)
      %assign isComplex = LibGetRecordIsComplex(bo)
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign dataLayout = SLibGetDataLayout(bo)
      %assign isInvariant = bo.Invariant == "yes"
      %assign baseSysIdx = GetBaseSystemIdx()
      %assign name = ...
          SLibGetBlockOutputIdentifierFromRecord(bo, baseSysIdx)
       
      %if SLibIsContainerCGTypeND(bo)
        %% Insert an nD reference to the first element if a flat index is
        %% used on an nD variable
        %assign recNumDims = LibCGTypeNumDimensions(SLibGetRecordContainerCGTypeIdx(bo))
        %assign id = LibGetAddressOfFirstElement(name, recNumDims)
        %assign baseAddr = "&%<id>%%<reim>"
      %else
        %assign baseAddr = "&%<name>%%<reim>"
      %endif
      %break
     
    %case "ExternalInput"
      %% external input signal
      %assign ei = record
      %assign dataTypeIdx = LibGetRecordDataTypeId(ei)
      %assign isComplex = LibGetRecordIsComplex(ei)
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign dataLayout = SLibGetDataLayout(ei)
      %assign name = FcnGetVarGroupElementPathFromRecord(ei)
      %assign baseAddr = "&%<name>%%<reim>"
      %break
 
    %case "ExternalOutput"
      %% external output signal
      %assign eo = record
      %assign sysIdx = eo.Block[0]
      %assign blkIdx = eo.Block[1]
      %assign oblock = System[sysIdx].Block[blkIdx]
      %assign ip = oblock.DataInputPort
      %assign dataTypeIdx = LibGetRecordDataTypeId(ip)
      %assign isComplex = LibGetRecordIsComplex(ip)
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign dataLayout = SLibGetDataLayout(eo)
      %assign name = FcnGetVarGroupElementPathFromRecord(eo)
      %assign baseAddr = "&%<name>%%<reim>"
      %break
     
    %case "ModelParameter"
      %% parameter
      %assign mdlParam = record
      %assign dataTypeIdx = LibGetRecordDataTypeId(mdlParam)
      %assign isComplex = LibGetRecordIsComplex(mdlParam)
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign dataLayout = SLibGetDataLayout(mdlParam)
      %if ISFIELD(mdlParam, "InstanceSpecific") && mdlParam.InstanceSpecific && !ISFIELD(mdlParam, "VarGroupIdx")
        %assign id = SLibGetGroupedParamQualifiedIdentifier(mdlParam)
      %else
        %assign id = FcnGetAutoParamIdentifier(mdlParam)
      %endif
      %assign baseAddr = "&%<id>%%<reim>"
      %break
     
    %case "DWork"
      %% dwork (states in paticular)
      %assign dwRec = record
      %assign dataTypeIdx = SLibDWorkDataTypeId(dwRec)
      %assign isComplex = SLibDWorkIsComplex(dwRec)
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign dataLayout = SLibGetDataLayout(dwRec)
      %assign baseSysIdx = GetBaseSystemIdx()
      %assign id = FcnGetDWorkIdentifier(dwRec, baseSysIdx)
      %assign baseAddr = "&%<id>%%<reim>"
      %break
       
    %case "ChartData"
      %assign chartData = record
      %assign dataTypeIdx = chartData.DataTypeIdx
      %assign isComplex = chartData.IsComplex
      %assign reim = isComplex ? ".%<tRealPart>" : ""
      %assign dataLayout = SLibGetDataLayout(chartData)
      %assign baseSysIdx = GetBaseSystemIdx()
      %assign dwRec = chartData.DWork
      %assign id = FcnGetDWorkIdentifier(dwRec, baseSysIdx)
      %assign baseAddr = "&%<id>.%<chartData.Name>%%<reim>"
      %break
       
    %case "ContState"
      %% Continuous States
      %assign cStateRec = record
      %assign dataTypeIdx = 0
      %assign isComplex = 0
      %assign reim = ""
      %assign dataLayout = SLibGetDataLayout(cStateRec)
      %assign baseSysIdx = GetBaseSystemIdx()
      %assign id = FcnGetCStateIdentifier(cStateRec, baseSysIdx)
      %assign baseAddr = "&%<id>%%<reim>"
      %if (structure.Name == "StateDerivatives")
    %assign baseAddr = "&(%<RTMGet("dX")>[0])"
      %endif
      %break
 
    %default
      %<LibReportFatalError("unknown section type.")>
  %endswitch
 
  %% create a structure section
  %% (Note: OffsetCounter is for internal use only)
  %addtorecord structure /
  Section { /
    DataTypeIdx dataTypeIdx; /
    IsComplex isComplex; /
    BaseAddr baseAddr; /
    NumElements 0; /
    NumData 0; /
    OffsetCounter 0 /
  }
   
  %% add section to structure
  %assign structure.NumSections = structure.NumSections + 1
   
  %% return section index
  %return structure.NumSections-1
%endfunction
 
 
%%Function:FcnAddStructure===================================================
%%Abstract:
%%Addastructuretoglobalmemorymap.
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%TopTester:test/toolbox/simulink/blocks/tconcat.m
%%TopTester:test/toolbox/simulink/variants/inlineVariants/simulinkFunction/tVariantSimulinkFunctionAutoInherit.m
%%
%function FcnAddStructure(name) void
   
  %% Get Default Type of the Structured Data
  %switch(name)
      %case "%<LibGetBlockIOStruct()>"
      %case ::tConstBlockIOStruct
      %case ::tInput
      %case "%<LibGetExternalOutputStruct()>"
    %assign defaultType = "signal"
    %break
      %case "%<LibGetParametersStruct()>"
    %assign defaultType = "parameter"
    %break
      %case "%<LibGetDWorkStruct()>"
      %case "%<LibGetContinuousStateStruct()>"
    %assign defaultType = "state"
    %break
      %case "StateDerivatives"
    %assign defaultType = "stateDerivative"
    %break
      %default
    %assign defaultType = "unknown"
  %endswitch
   
  %% add record to global map
  %assign gmm = GlobalMemoryMap
   
  %addtorecord gmm /
  StructuredData { /
    Name name; /
    NumTotalElements 0; /
    NumSections 0 /
    DataDefaults { /
      Class "scalar" /
      HasObject TLC_FALSE /
      IsFixedPoint TLC_FALSE /
      IsStruct TLC_FALSE /
      NumDimensions 2 /
      NumCols 1 /
      NumRows 1 /
      Permission "rw" /
      PPIf "" /
      PPEndIf "" /
      Type defaultType /
    } /
  }
 
  %% increment number of structured data records
  %assign gmm.NumStructuredData = gmm.NumStructuredData + 1
 
  %% return index to newly created record
  %return gmm.NumStructuredData-1
%endfunction
 
 
%%Function:FcnAddToModelParameters===========================================
%%Abstract:
%%AdddatatoModelParameters.
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants9.m
%%
%function FcnAddToModelParameters(record) void
 
  %assign cmModelParams = ::CompiledModel.ModelParameters
  %assign gmmModelParams = GlobalMemoryMap.ModelParameters
  %assign instanceCache = gmmModelParams.InstanceCache
  %assign signalInstanceCache = gmmModelParams.SignalInstanceCache
  %assign groupIdx = -1
   
  %switch record.RecordType
 
    %case "ModelParameter"
     
      %% Simulink parameter
       
      %assign mdlParam = record
      %assign source = "SL"
      %if ISFIELD(record, "VarGroupIdx") && ...
        LibGetVarGroupCategory(record.VarGroupIdx[0]) == "HierarchicalCoderData"
        %assign groupIdx = ::CompiledModel.VarGroups.VarGroup[record.VarGroupIdx[0]].CoderDataGroupIndex
      %endif
       
      %if InlineParameters != 0 || mdlParam.ReferencedBy[0][0] == -1
    %assign paramName = LibGetRecordIdentifier(mdlParam)
      %else
        %assign sysIdx = mdlParam.ReferencedBy[0][0]
        %assign blkIdx = mdlParam.ReferencedBy[0][2]
        %assign block = System[sysIdx].Block[blkIdx]
        %assign prmIdx = mdlParam.ReferencedBy[0][3]
    %assign paramName = block.Parameter[prmIdx].String
      %endif
       
      %assign paramKey = "Key_" + paramName
 
      %assign numBlocks = SIZE(mdlParam.GraphicalRef,0)
  
      %if numBlocks == 0
          %assign parent = "Dummy"
      %else
          %if numBlocks == 1
              %assign parent = SLibGrBlockPath(mdlParam.GraphicalRef[0])
          %else
              %if numBlocks > 1
                  %assign parent = "multiple"
              %endif
          %endif
       %endif
 
      %assign memoryMapIdx = mdlParam.MemoryMapIdx
      %%
      %% create an alias for the model parameter for future reference
      %% by Stateflow. This is needed to resolve SL/SF combinatorics
      %% issues when InlineParameters is on and the storage class
      %% is external.
      %%
      %if mdlParam.StorageClass != "Auto"
    %addtorecord cmModelParams %<paramKey> mdlParam
      %endif
      %break
 
    %case "MachineData"
       
      %% Stateflow data
 
      %assign sfInfo = record
      %assign paramName = sfInfo.Name
      %assign paramKey = "Key_" + paramName
 
      %% check that it's not a Simulink signal
      %if GMMConflictChecking && ISFIELD(signalInstanceCache, paramName)
    %assign errTxt = "Cannot declare machine parented " ...
      "Stateflow data the same as a Simulink signal: %<paramName>"
    %<LibReportFatalError(errTxt)>
      %endif
      %%
      %% handle the SL/SF combinatorics.
      %%
      %assign isExternSimulinkParam = 0
 
      %if ISFIELD(cmModelParams, paramKey)
    %assign slParam = ::CompiledModel.ModelParameters.%<paramKey>
    %assign isExternSimulinkParam = slParam.StorageClass != "Auto" ? 1 : 0
      %endif
      %if isExternSimulinkParam
    %% check for Simulink conflict
    %assign slScope = slParam.StorageClass
    %if (slScope == "ImportedExternPointer") || ...
      (slScope == "ExportedGlobal" && sfInfo.Scope == "Exported")
      %% error
      %assign errTxt = "/n/n"...
        "Data definition conflict between " ...
        "Simulink and Stateflow for variable '%<paramName>'. " ...
        "The Simulink storage class is " ...
        "'%<slParam.StorageClass>' and the Stateflow scope is " ...
        "'%<sfInfo.Scope>'. The recommended Stateflow scope " ...
        "is 'Exported' with Simulink storage class 'ImportedExtern'."
      %<LibReportFatalError(errTxt)>
    %else
      %% SL/SF are using the same memory. Need to change the source
      %% and parent and type of the previously created SL instance
      %% to "multiple".
      %assign idx = instanceCache.%<paramKey>
      %assign parameter = gmmModelParams.ModelParameter[idx]
      %assign parameter.Instance.Source = "multiple"
      %assign parameter.Instance.Parent = "multiple"
      %assign dataIdx = parameter.Instance.MemoryMapIdx[2]
      %assign usd = GlobalMemoryMap.UnstructuredData.Data[dataIdx]
      %assign usd.Type = "multiple"
      %% early return
      %return ""
    %endif
      %else
    %% No conflict with Simulink, so add an instance
    %assign source = "SF"
    %assign parent = "Machine"
    %assign dataIdx = FcnAddUnstructuredData(sfInfo)
    %assign memoryMapIdx = [-1, -1, %<dataIdx>]
      %endif
      %break
       
    %default
      %<LibReportFatalError("unknown source: %<source>")>
  %endswitch
 
  %%
  %% create the instance
  %%
  %if ISFIELD(record, "GraphicalRef")
    %assign blkGrRef = record.GraphicalRef
  %else
    %assign blkGrRef = [-1 -1]
  %endif
   
  %createrecord /
  Instance { /
    Source source; /
    Parent parent; /
    MemoryMapIdx memoryMapIdx /
    BlkGrRef blkGrRef /
  }
   
  %%
  %% create a new model parameter if one doesn't exist
  %%
   
  %%if ISFIELD(instanceCache, paramKey) == TLC_FALSE
  %if ISFIELD(instanceCache, paramKey) == TLC_FALSE
    %% create new model parameter (note that NumInstances is
    %% incremented below)
    %createrecord /
    ModelParameter { /
      Name paramName; /
      NumInstances 0 /
    }
    %if groupIdx >= 0
      %addtorecord ModelParameter CoderDataGroupIdx groupIdx
    %endif
    %% Attach ModelParameter to GlobalMemoryMap.ModelParameters
    %assign gmmModelParams = gmmModelParams + ModelParameter
    %% Assign the cached value to be the index of the ModelParameter
    %% and add it to the instance cache
    %addtorecord instanceCache %<paramKey> gmmModelParams.NumModelParameters
    %assign instanceCache.NumCachedVariables = instanceCache.NumCachedVariables + 1
    %% Increment the number of model parameters
    %assign gmmModelParams.NumModelParameters = gmmModelParams.NumModelParameters + 1
  %endif
   
  %assign idx = instanceCache.%<paramKey>
  %assign parameter = gmmModelParams.ModelParameter[idx]
  %assign parameter.NumInstances = parameter.NumInstances + 1
  %assign parameter = parameter + Instance
   
%endfunction
 
%%Function:localGetHStructInstanceIdx========================================
%%Abstract:
%%Thisfunctionmakessurethatwedon'tcreatanewsectionbetweensignals
%%intherootsystemandnon-reusedsubsystems.
%%Toptetser:test/toolbox/simulink/blocks/tconcat.m
%%TopTester:test/toolbox/simulink/variants/string/tStringSupport.m
%%
%function localGetHStructInstanceIdx(hStructInstanceIdx)
  %if hStructInstanceIdx < 0
    %return 0
  %else
    %return hStructInstanceIdx
  %endif
%endfunction
 
%%Function:FcnMapParameters==================================================
%%Abstract:
%%Thisfunctioncreatesamapofallmodelparametersnotofcustom
%%storageclass.
%%TopTester:test/toolbox/simulink/variants/string/tStringSupport.m
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants2.m
%%
%function FcnMapParameters() void
 
  %if !::CompiledModel.BlockOutputsMapped || !::CompiledModel.ExternalInputsMapped
    %assign errTxt = "Block output and external signals must be mapped " ...
      "prior to parameters."
    %<LibReportFatalError(errTxt)>
  %endif
 
  %with ModelParameters
    %% Map rtP (structured data)
    %if (!SLibModelParametersStructIsEmpty() || SLibNonEmptyParamCoderGroupExists()) && !IsModelReferenceSimTarget()
 
      %% Add parameters structure to global memory map
       
      %assign structIdx = FcnAddStructure("%<LibGetParametersStruct()>")
      %assign struct = GlobalMemoryMap.StructuredData[structIdx]
       
      %assign prevComplex = -1
      %assign prevDataTypeIdx = -1
      %assign prevHStructSystemIdx = -1
      %assign prevHStructInstanceIdx = -1
      %assign paddingRequired = TLC_FALSE
       
      %foreach mdlParamIdx = NumInrtP
        %assign mdlParam = Parameter[mdlParamIdx]
 
        %% When InlineParameters == 2 (the AllTunable mode), unstructured
        %% parameters can be in the rtP structure as well. These parameters
        %% will be handled later in this function.
        %if SLibIsParamUnstructured(mdlParam)
          %continue
        %endif
        %if !mdlParam.InstanceSpecific && SLibOmitRecord(mdlParam)
          %continue
        %endif
         
        %% If this is a Parameter Mapped to Legacy CSC, skip it
        %% here. It will be mapped with Custom Parameters in
        %% FcnMapCustomParameters.
        %if SLibIsLegacyStorageClassForDataRecord(mdlParam)
          %continue
        %endif
         
        %if (mdlParam.UseAUTOSARFunctions == 1)
          %continue
        %endif
 
        %if mdlParam.SuppressInRTW
          %continue
        %endif
         
        %if SLibGetWidthOfValueFromParamRec(mdlParam) == 0
          %continue
        %endif
         
        %if ISFIELD(mdlParam, "VarGroupIdx") && mdlParam.VarGroupIdx[0] >= 0
          %assign mdlParamVGIdx = mdlParam.VarGroupIdx[0]
          %assign mdlParamVG = ::CompiledModel.VarGroups.VarGroup[mdlParamVGIdx]
          %if SLibIsCoderGroupVarGroup(mdlParamVG) && !mdlParamVG.PackageAsStruct
            %continue
          %endif
        %endif
         
        %% Look for transitions which occur if:
        %% - change in complexity
        %% - change in data type
        %% - structure padding
        %% - change in heirarchy level
        %% The last is needed so that the global map automatically
        %% handles any padding the compilers might add to enforce
        %% a byte alignment for the substructures
        %assign HStructSystemIdx = mdlParam.OwnerSysIdx[0]
        %assign HStructInstanceIdx = ...
          localGetHStructInstanceIdx(mdlParam.OwnerSysIdx[1])
        %assign dataTypeIdx = LibGetRecordStorageDataTypeId(mdlParam)
        %% Use original type (not storage type) if parameter has string type
        %% Different string types can share the same storage type in accelerator and rapid accelerator
        %% We need to preserve that difference by adding sections
        %if ISFIELD(mdlParam, "OriginalDataTypeIdx") && LibIsStringDataType(mdlParam.OriginalDataTypeIdx)
          %assign dataTypeIdx = mdlParam.OriginalDataTypeIdx
        %endif
        %assign paramHasStructDataTypeAndIsNotFixedPoint = ...
          LibIsStructDataType(dataTypeIdx) && !LibIsDataTypeFixpt(dataTypeIdx)
         
        %if (LibGetRecordIsComplex(mdlParam) != prevComplex) || ...
          (dataTypeIdx != prevDataTypeIdx) || ...
          (HStructSystemIdx != prevHStructSystemIdx) || ...
          (HStructInstanceIdx != prevHStructInstanceIdx) || ...
          paddingRequired || paramHasStructDataTypeAndIsNotFixedPoint
           
          %% add new parameters section
          %assign secIdx = FcnAddSection(struct, mdlParam)
          %assign section = struct.Section[secIdx]
          %assign prevComplex = LibGetRecordIsComplex(mdlParam)
          %assign prevDataTypeIdx = dataTypeIdx
          %assign prevHStructSystemIdx = HStructSystemIdx
          %assign prevHStructInstanceIdx = HStructInstanceIdx
        %endif
        %assign paddingRequired = (mdlParam.Padding>0) ? TLC_TRUE : TLC_FALSE
         
        %% Add data record to section
        %assign dataIdx = FcnAddStructuredData(struct, section, mdlParam)
         
        %% Add MemoryMapIdx to ModelParameter record
         
        %assign mdlParam.MemoryMapIdx = [%<structIdx>,%<secIdx>,%<dataIdx>]
         
        %if InlineParameters != 0
          %% Parameter collapsed to a single memory address in rtP and corresponds
          %% to a workspace variable. Add it as a model parameter
          %if mdlParam.Tunable == "yes" && mdlParam.StorageClass == "Auto" && !ISEMPTY(mdlParam.WorkspaceVarName)
            %<FcnAddToModelParameters(mdlParam)>
          %endif
        %elseif mdlParam.ReferencedBy[0][0] != -1
          %% Each parameter is unique. Optionally, add as model parameter
          %% if the parameter field is exclusively a MATLAB variable. (Note
          %% that FcnAddToModelParameter manages multiple instances of
          %% a variable).
          %assign sysIdx = mdlParam.ReferencedBy[0][0]
          %assign blkIdx = mdlParam.ReferencedBy[0][2]
          %assign prmIdx = mdlParam.ReferencedBy[0][3]
          %assign block = System[sysIdx].Block[blkIdx]
          %assign blkParam = block.Parameter[prmIdx]
          %if blkParam.StringType == "Variable" && block.InMask != "yes"
            %<FcnAddToModelParameters(mdlParam)>
          %endif
        %endif
        %<FcnUpdateBlockParameterMemoryMapIdx(mdlParam)>
      %endforeach %% ModelParameter
    %endif %% LibParametersStructIsEmpty()
     
    %% Map interfaced parameters (unstructured data)
     
    %if InlineParameters != 0
      %% Add SimulinkGlobal parameters if they are unstructured
      %foreach mdlParamIdx = NumInrtP
        %assign mdlParam = Parameter[mdlParamIdx]
        %if SLibIsParamUnstructured(mdlParam)
          %assign dataIdx = FcnAddUnstructuredData(mdlParam)
          %assign mdlParam.MemoryMapIdx = [-1, -1, %<dataIdx>]
          %<FcnAddToModelParameters(mdlParam)>
          %<FcnUpdateBlockParameterMemoryMapIdx(mdlParam)>
        %endif
      %endforeach
      %% Add the other unstructured parameters
      %assign pOffset = NumInrtP + NumConstPrmsWithInit + NumConstPrms
      %assign numExterns = NumExportedGlobal + NumImportedExtern + NumImportedExternPointer
      %foreach idx = numExterns
    %assign mdlParamIdx = pOffset + idx
    %assign mdlParam = Parameter[mdlParamIdx]
    %assign dataIdx = FcnAddUnstructuredData(mdlParam)
    %assign mdlParam.MemoryMapIdx = [-1, -1, %<dataIdx>]
    %<FcnAddToModelParameters(mdlParam)>
    %<FcnUpdateBlockParameterMemoryMapIdx(mdlParam)>
      %endforeach
    %else
      %assign pOffset = NumInrtP + NumConstPrmsWithInit + NumConstPrms + ...
        NumExportedGlobal + NumImportedExtern + NumImportedExternPointer
      %foreach idx = NumInMdlRefGlobal
    %assign mdlParamIdx = pOffset + idx
    %assign mdlParam = Parameter[mdlParamIdx]
    %assign dataIdx = FcnAddUnstructuredData(mdlParam)
    %assign mdlParam.MemoryMapIdx = [-1, -1, %<dataIdx>]
    %<FcnAddToModelParameters(mdlParam)>
    %<FcnUpdateBlockParameterMemoryMapIdx(mdlParam)>
      %endforeach
    %endif
     
  %endwith %% ModelParameters
 
  %assign ::CompiledModel.ParametersMapped = 1
 
%endfunction
 
 
%%Function:FcnMapCustomParameters===========================================
%%Abstract:
%%Thisfunctioncreatesamapofallmodelparameterswithcustom
%%storageclass
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function FcnMapCustomParameters() void
 
  %if !::CompiledModel.BlockOutputsMapped || !::CompiledModel.ExternalInputsMapped
    %assign errTxt = "Block output and external signals must be mapped " ...
      "prior to parameters."
    %<LibReportFatalError(errTxt)>
  %endif
 
  %with ModelParameters
    %if InlineParameters != 0
      %assign numExterns = NumExportedGlobal + NumImportedExtern + NumImportedExternPointer
      %assign pOffset = NumInrtP + NumConstPrmsWithInit + ...
                    NumConstPrms + numExterns
 
      %% Map all the explicit Custom Storage Class Parameters
      %foreach idx = NumCustomStorageClass
        %assign mdlParamIdx = pOffset + idx
        %assign mdlParam = Parameter[mdlParamIdx]
        %<FcnMapCustomParameterHelper(mdlParam)>
      %endforeach
       
      %% Now map all the Default Mapped Parameters
      %foreach idx = NumParameters
        %assign mdlParam = Parameter[idx]
        %if SLibIsLegacyStorageClassForDataRecord(mdlParam)
          %<FcnMapCustomParameterHelper(mdlParam)>
        %endif
      %endforeach
 
    %endif
  %endwith %% ModelParameters
 
  %assign ::CompiledModel.ParametersMapped = 1
 
%endfunction
 
 
%%Function:FcnMapCustomParameterHelper=================================
%%Abstract:
%%Thisfunctionisahelperfunctiontotheabovefunction
%function FcnMapCustomParameterHelper(mdlParam) void
  %assign dataIdx = FcnAddCustomData(mdlParam)
  %assign package = LibGetRTWInfoObjectPackage(mdlParam)
  %assign class = LibGetCustomStorageClassName(mdlParam)
  %assign classIdx = SLibGetCustomStorageIdxInMap(package, class)
  %assign mdlParam.MemoryMapIdx = [-1, %<classIdx>, %<dataIdx>]
  %<FcnAddToModelParameters(mdlParam)>
  %<FcnUpdateBlockParameterMemoryMapIdx(mdlParam)>
%endfunction
 
 
%%Function:FcnUpdateBlockParameterMemoryMapIdx===============================
%%Abstract:
%%Thisfunctioncopiesthememorymapindexfromamodelparameter
%%toablockparameter
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants9.m
%%
%function FcnUpdateBlockParameterMemoryMapIdx(mdlParam) void
  %if mdlParam.MemoryMapIdx[2] != -1
        %foreach refIdx = SIZE(mdlParam.ReferencedBy,0)
          %assign sysIdx = mdlParam.ReferencedBy[refIdx][0]
          %if sysIdx != -1
            %assign blkIdx = mdlParam.ReferencedBy[refIdx][2]
            %assign block = System[sysIdx].Block[blkIdx]
            %%
            %% Generate a mapping for the block parameter iff:
            %% 1. The model parameter is used directly by a non-subsystem block.
            %% 2. The model parameter is not part of an expression within that
            %% block's paramter.
            %%
            %if block.Type != "SubSystem"
              %assign prmIdx = mdlParam.ReferencedBy[refIdx][3]
              %if prmIdx != -1
                %assign blkParam = block.Parameter[prmIdx]
                %if ISFIELD(blkParam, "ASTNode")
                  %if blkParam.ASTNode.IsNonTerminal == 0
                    %% %assert LibGetRecordIdentifier(blkParam.ASTNode)
                    %% == LibGetRecordIdentifier(mdlParam)
                    %assign blkParam.MemoryMapIdx = mdlParam.MemoryMapIdx
                  %endif
                %elseif blkParam.MdlPrmIdx >= 0
                  %assign blkParam.MemoryMapIdx = mdlParam.MemoryMapIdx
                %endif
              %endif
            %endif
          %endif
        %endforeach
  %endif
%endfunction
 
%function FcnSubsystemsHaveBlockIO() void
  %assign sysBlkIO = TLC_FALSE
  %foreach sysIdx = ::CompiledModel.NumSystems-1
    %assign ssHasBlkIO = (System[sysIdx].StandaloneSubsystem) && ...
      (System[sysIdx].HasBlockIOArg == 1)
    %assign sysBlkIO = sysBlkIO || ssHasBlkIO
  %endforeach
  %return sysBlkIO
%endfunction
 
%function FcnSubsystemsHaveDWork() void
  %assign sysDWork = TLC_FALSE %% assume
  %foreach sysIdx = ::CompiledModel.NumSystems-1
    %assign ssHasDWork = (System[sysIdx].StandaloneSubsystem) && ...
      (System[sysIdx].HasDWorkArg == 1)
    %assign sysDWork = sysDWork || ssHasDWork
  %endforeach
  %return sysDWork
%endfunction
 
%function FcnSubsystemsHaveConstBlockIO() void
  %assign sysCBlockIO = TLC_FALSE %% assume
  %foreach sysIdx = ::CompiledModel.NumSystems-1
    %assign ssHasConstBlockIO = (System[sysIdx].StandaloneSubsystem) && ...
      (System[sysIdx].HasConstBlockIOArg == 1)
    %assign sysCBlockIO = sysCBlockIO || ssHasConstBlockIO
  %endforeach
  %return sysCBlockIO
%endfunction
 
%function FcnSubsystemsHaveCStates() void
  %assign sysCStates = TLC_FALSE %% assume
  %foreach sysIdx = ::CompiledModel.NumSystems-1
    %assign ssHasCStates = (System[sysIdx].StandaloneSubsystem) && ...
      (System[sysIdx].HasCStatesArg == 1)
    %assign sysCStates = sysCStates || ssHasCStates
  %endforeach
  %return sysCStates
%endfunction
 
%function FcnSubsystemsHaveParams() void
  %assign sysParams = TLC_FALSE %% assume
  %foreach sysIdx = ::CompiledModel.NumSystems-1
    %assign ssHasParams = (System[sysIdx].StandaloneSubsystem) && ...
      (System[sysIdx].HasParametersArg == 1)
    %assign sysParams = sysParams || ssHasParams
  %endforeach
  %return sysParams
%endfunction
 
%function FcnSubsystemsHaveCDeriv() void
  %assign sysCDeriv = TLC_FALSE %% assume
  %foreach sysIdx = ::CompiledModel.NumSystems-1
    %assign ssHasCDeriv = (System[sysIdx].StandaloneSubsystem) && ...
      (System[sysIdx].HasCStatesDerivArg == 1)
    %assign sysCDeriv = sysCDeriv || ssHasCDeriv
  %endforeach
  %return sysCDeriv
%endfunction
 
%%Function:prepareDWorkRecord================================================
%%Abstract:
%%PreparesaDWorkrecordtobeincludedintheGlobalMemoryMap.
%%TopTester:test/toolbox/fixpoint/fixpt_autoscale/MLFB/apply_workflow/t_edit_operations2.m
%%
%function prepareDWorkRecord(dwRec) void
  %assign srcBlk = System[dwRec.SigSrc[0]].Block[dwRec.SigSrc[2]]
  %assign blkIsStateflow = BlockIsStateflowSFunction(srcBlk)
  %%
  %if blkIsStateflow
    %assign synthesized = ...
      System[dwRec.SigSrc[0]].Synthesized
    %% MATLAB Function blocks may be inserted at compile-time for
    %% MATLAB System blocks in codegen mode - since these are
    %% synthesized blocks, there is no need to include them in the
    %% Global Memory Map
    %if !synthesized
      %assign grBlk = ...
        BlockHierarchyMap.Subsystem[dwRec.GrSrc[0]].Block[dwRec.GrSrc[1]]
      %%
      %if !ISFIELD(grBlk, "ChartData")
        %% Get and cache chart data map for stateflow block
        %generatefile "chartSource" "%<srcBlk.SFInfo.ChartTLCFile>.tlc"
        %assign chartDataMap = ...
          GENERATE_TYPE(srcBlk, "ChartDataMap", "chartSource", ...
          System[dwRec.SigSrc[0]])
        %addtorecord grBlk ChartData chartDataMap
      %else
        %% Return cached chart data map
        %assign chartDataMap = grBlk.ChartData
      %endif
      %%
      %% Attach dimension info for SF chart dwork record if it is a matrix
      %%
      %assign localDwIdx = dwRec.SigSrc[3]
      %if localDwIdx < chartDataMap.NumChartData && ...
        LibCGTypeIsMatrix(LibGetRecordCGTypeIdx(dwRec))
        %% Skip dwork records with index exceeding number of Stateflow registered
        %% dworks. These dworks are not created by Stateflow, e.g. block variable
        %% size output port size var.
        %addtorecord dwRec Dimensions chartDataMap.ChartData[localDwIdx].Dimensions
      %endif
    %endif
  %endif
%endfunction
 
%%Function:VarGroupRecordRequired============================================
%%Abstact:
%%ReturnsadatarecoredifitisrequiredintheGlobalMemoryMap.
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants9.m
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants5.m
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortEnable.m
%%TopTester:test/toolbox/simulink/blocks/lib_MathOperations/Gain/rtw/tGainBlk_Codegencheck_ERT_GRT.m
%%
%function getVGElementRequiredRec(aRecType, aRecIdx) void
  %switch aRecType
    %case "W"
      %assign dwRec = DWorks.DWork[aRecIdx]
      %if dwRec.IsLocalScratchDWork == 1
        %return []
      %endif
      %assert dwRec.StorageClass == "Auto"
      %if !SLibOmitRecord(dwRec) && dwRec.BitFieldWidth == 0
        && !SLibGetDWorkIsCanDimSizeDWorkInBaseSys(aRecIdx) ...
        && !FcnIsDWorkFromMdlBlockInCppClassGenMode(dwRec)
        %%
        %<prepareDWorkRecord(dwRec)>
        %return dwRec
      %endif
      %break
    %case "B"
      %assign boRec = BlockOutputs.GlobalBlockOutput[aRecIdx]
      %if boRec.BitFieldWidth == 0 ...
        && boRec.RequiredInBlockIO[0] == 1 && boRec.RequiredInBlockIO[1] == 0 ...
        && boRec.NumReusedBlockOutputs == 0
        %%
        %return boRec
      %endif
      %break
    %case "C"
      %assign boRec = BlockOutputs.ConstBlockOutput[aRecIdx]
      %if boRec.RequiredInConstBlockIO && boRec.NumReusedBlockOutputs == 0
        %return boRec
      %endif
      %break
    %case "U"
      %assign extURec = ExternalInputs.ExternalInput[aRecIdx]
      %return extURec
    %case "Y"
      %assign extYRec = ExternalOutputs.ExternalOutput[aRecIdx]
      %return extYRec
    %default
      %break
  %endswitch
  %return []
%endfunction
 
%%Function:MapVarGroup=======================================================
%%Abstract:
%%AddstheExternalOutputIdxtotheblockrecord.
%%
%function FcnAssignExternalOutputIdxToBlock(eoRec, recIdx) void
  %assign sysIdx = eoRec.Block[0]
  %assign blkIdx = eoRec.Block[1]
  %assign oblock = System[sysIdx].Block[blkIdx]
  %if SLibGraphicalBlockExist(oblock)
    %assign grBlockIndex = SLibGetGraphicalBlockIdx(oblock)
    %assign grSubSys = ::CompiledModel.BlockHierarchyMap.Subsystem[grBlockIndex[0]]
    %assign grBlock = grSubSys.Block[grBlockIndex[1]]
    %addtorecord grBlock ExternalOutputIdx recIdx
  %endif
%endfunction
 
%%Function:MapVarGroup=======================================================
%%Abstract:
%%Addsastructurerepresentedbyavar-grouptotheglobalmemorymap
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%Toptetser:test/toolbox/simulink/variants/tvss_sim_code_match_g984892.m
%%
%function MapVarGroup(aVarGroupIdx, aStructIdx) void
  %if aVarGroupIdx < 0
    %return
  %endif
  %assign struct = GlobalMemoryMap.StructuredData[aStructIdx]
  %assign varGroup = VarGroups.VarGroup[aVarGroupIdx]
  %assign isCoderGroupVarGroup = SLibIsCoderGroupVarGroup(varGroup)
  %if 0 == varGroup.PackageAsStruct
    %if varGroup.IsModelSelfCoderGroupVarGroup
      %foreach elementIdx = varGroup.NumVarGroupElements
        %assign idnum = IDNUM(varGroup.VarGroupElements[elementIdx])
        %if("VG" == idnum[0])
          %<MapVarGroup(idnum[1], aStructIdx)>
        %endif
      %endforeach
    %endif
    %return
  %endif
  %assign cgType = CGTypes.CGType[varGroup.CGTypeIdx]
  %assign prevDataTypeIdx = -1
  %assign prevComplex = "unknown"
  %assign prevRecType = "unknown"
  %assign paddingRequired = TLC_FALSE
  %%
  %% Loop through the vargroup members
  %%
  %assign cgTypeIdx = varGroup.CGTypeIdx
  %if LibCGTypeIsMatrix(varGroup.CGTypeIdx)
    %assign cgTypeIdx = LibCGTypeBaseIndex(varGroup.CGTypeIdx)
    %assign cgType = ::CompiledModel.CGTypes.CGType[cgTypeIdx]
  %endif
  %assert LibCGTypeIsStruct(cgTypeIdx)
  %assert LibCGTypeNumMembers(cgTypeIdx) == varGroup.NumVarGroupElements
 
  %assign needNewSection = TLC_FALSE
  %foreach mIdx = LibCGTypeNumMembers(cgTypeIdx)
    %assign idnum = IDNUM(varGroup.VarGroupElements[mIdx])
    %assign recType = idnum[0]
    %assign recIdx = idnum[1]
    %if recType == "VG"
      %<MapVarGroup(recIdx, aStructIdx)>
    %else
      %assign dataRec = getVGElementRequiredRec(recType, recIdx)
      %if !ISEMPTY(dataRec)
        %if needNewSection || paddingRequired || ...
          (!isCoderGroupVarGroup && recType != prevRecType) || ...
          (LibGetRecordStorageDataTypeId(dataRec) != prevDataTypeIdx) || ...
          (LibGetRecordIsComplex(dataRec) != prevComplex) || ...
          LibIsStringDataType(prevDataTypeIdx)
          %%
          %% add new section
          %%
          %assign secIdx = FcnAddSection(struct, dataRec)
          %assign section = struct.Section[secIdx]
          %assign prevDataTypeIdx = LibGetRecordStorageDataTypeId(dataRec)
          %assign prevComplex = LibGetRecordIsComplex(dataRec)
        %endif
        %%
        %% paddingRequired - still might be used by the Accelerator
        %%
        %assign paddingRequired = ...
          (dataRec.Padding > 0) ? TLC_TRUE : TLC_FALSE
        %%
        %% add data record to section
        %%
        %assign dataIdx = FcnAddStructuredData(struct, section, dataRec)
        %%
        %% update MemoryMapIdx
        %%
        %assign dataRec.MemoryMapIdx = [%<aStructIdx>, %<secIdx>, %<dataIdx>]
        %%
        %assign needNewSection = TLC_FALSE
         %% Need some special handling for data group root outputs
        %if (LibGetVarGroupCategory(aVarGroupIdx) == "HierarchicalCoderData" && recType == "Y")
          %<FcnAssignExternalOutputIdxToBlock(dataRec, recIdx)>
        %endif
      %else %% elementent inserted during varGroup manipulation
        %assign needNewSection = TLC_TRUE
      %endif
    %endif
    %assign prevRecType = recType
  %endforeach
%endfunction
 
%%Function:FcnMapBlockIO=====================================================
%%Abstract:
%%Thisfunctioncreatesamapofallblockoutputsignalsnotofcustom
%%storageclass.NotethatBlockOutputsisnotsortedbydatatype.
%%Therefore,it'snecessarytomakemultiplepassesthroughBlockOutputs
%%inordertoextractallnecessaryinformation.
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants3.m
%%
%function FcnMapBlockIO() void
  %with BlockOutputs
    %%
    %% block I/O signals
    %%
    %if !SLibModelBlockIOStructIsEmpty()
      %%
      %% add block I/O to global memory map
      %%
      %assign structIdx = FcnAddStructure(LibGetBlockIOStruct())
      %assign varGroupIdx = ...
        FcnSysVarGroupIndex(System[GetBaseSystemIdx()], "BlockIO", 0)
      %<MapVarGroup(varGroupIdx, structIdx)>
    %endif
    %%
    %% const block I/O signals
    %%
    %if !SLibModelConstBlockIOStructIsEmpty()
      %%
      %% add const block I/O to global memory map
      %%
      %assign structIdx = FcnAddStructure(::tConstBlockIOStruct)
      %assign varGroupIdx = ...
        FcnSysVarGroupIndex(System[GetBaseSystemIdx()], "ConstBlockIO", 0)
      %<MapVarGroup(varGroupIdx, structIdx)>
    %endif
    %%
    %% block I/O for standalone subsystems (if any)
    %%
    %if ::CompiledModel.StandaloneSSSupported == 1
      %assign baseSysIdx = GetBaseSystemIdx()
      %foreach varIdx = VarGroups.NumVarGroups
        %assign vGrp = VarGroups.VarGroup[varIdx]
        %if ( (vGrp.Category == "BlockIO") && ...
          (vGrp.ParentVarGroupIdx == -1) && ...
          (vGrp.SysIdx < baseSysIdx) )
          %%
          %% add block I/O to global memory map
          %%
          %assign structIdx = FcnAddStructure(LibGetBlockIOStruct())
          %assign varGroupIdx = ...
            FcnSysVarGroupIndex(System[vGrp.SysIdx], "BlockIO", 0)
          %<MapVarGroup(varGroupIdx, structIdx)>
        %endif
      %endforeach
    %endif
    %%
    %% external signal
    %%
    %if !SLibExportedGlobalSignalsIsEmpty() || ...
      !SLibImportedExternSignalsIsEmpty() || ...
      !SLibImportedExternPointerSignalsIsEmpty()
      %foreach boIdx = NumExternalBlockOutputs
    %assign bo = ExternalBlockOutput[boIdx]
    %if !SLibOmitRecord(bo) && bo.StorageClass != "Custom"
      %assign dataIdx = FcnAddUnstructuredData(bo)
      %assign bo.MemoryMapIdx = [-1, -1, %<dataIdx>]
    %endif
      %endforeach
    %endif
  %endwith %% BlockOutputs
   
  %assign ::CompiledModel.BlockOutputsMapped = 1
%endfunction
 
%%Function:PrepareForMappingBlockIO===============================================
%%Abstract:
%%ThisfunctionpreparesformappingexternalinputandblockoutputsignalswithCSCrecord.
%%IftherearemultiplesignalscarryingthesameCSCrecord(e.g.Reusable),
%%prefertheonethatisassociatedwiththeexternalinputoroutput.
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants9.m
%%
%function PrepareForMappingBlockIO() void
  %with BlockOutputs
    %if NumCustomStorageClasses > 0
      %foreach boIdx = NumExternalBlockOutputs
        %assign bo = ExternalBlockOutput[boIdx]
        %if ISFIELD(bo, "DrivesRootOutport") && bo.DrivesRootOutport == "yes"
          %<LibAddIdentifier(bo, "IsAtRootInputOrOutput", TLC_TRUE)>
        %endif
      %endforeach
    %endif
  %endwith
  %with ExternalInputs
    %foreach eiIdx = NumExternalInputs
      %assign ei = ExternalInput[eiIdx]
      %<LibAddIdentifier(ei, "IsAtRootInputOrOutput", TLC_TRUE)>
    %endforeach
  %endwith
%endfunction
 
%%FunctionSLibIsLegacyStorageClassRecord
%%KRAMKUMA:HelperfunctiontoaddalldefaultstofcnAddCustomData
%function SLibIsLegacyStorageClassRecord(record) void
  %if record.StorageClass == "Custom"
    %return TLC_TRUE
  %elseif SLibIsLegacyStorageClassForDataRecord(record)
    %return TLC_TRUE
  %endif
  %return TLC_FALSE
%endfunction
 
%%Function:FcnMapCustomBlockIO===============================================
%%Abstract:
%%Thisfunctioncreatesamapofallblockoutputsignalswithcustom
%%storageclass.NotethatBlockOutputsisnotsortedbydatatype.
%%Therefore,it'snecessarytomakemultiplepassesthroughBlockOutputs
%%inordertoextractallnecessaryinformation.
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function FcnMapCustomBlockIO() void
  %with BlockOutputs
    %if NumCustomStorageClasses > 0
      %foreach vgIdx = VarGroups.NumVarGroups
        %assign varGroup = VarGroups.VarGroup[vgIdx]
        %if SLibIsCoderGroupVarGroup(varGroup)
          %assign coderGroupIndex = varGroup.CoderDataGroupIndex
          %assign coderGroup = ::CompiledModel.CoderDataGroup[coderGroupIndex]
          %if (coderGroup.IsLegacyStorageClass)
            %foreach vgElementIdx = varGroup.NumVarGroupElements
              %assign vgElement = SLibVarGroupElementSource(vgIdx, vgElementIdx)
              %assign idNumElement = IDNUM(vgElement)
              %assign recType = idNumElement[0]
              %assign recIdx = idNumElement[1]
              %if (recType == "L" || recType == "LDW" || recType == "S")
                %assign rec = SLibGetDataRecForVarGroupMember(recType, recIdx)
                %if (!ISEMPTY(rec) && !ISFIELD(rec, "VarGroupIdx"))
                  %assign fieldName = "VarGroupIdx"
                  %addtorecord rec %<fieldName> [%<vgIdx>, %<vgElementIdx>]
                %endif
              %endif
            %endforeach
          %endif
        %endif
      %endforeach
 
      %foreach boIdx = NumExternalBlockOutputs
        %assign bo = ExternalBlockOutput[boIdx]
        %if !SLibOmitRecord(bo) && bo.StorageClass == "Custom"
          %assign dataIdx = FcnAddCustomData(bo)
          %assign package = LibGetRTWInfoObjectPackage(bo)
          %assign class = LibGetCustomStorageClassName(bo)
          %assign classIdx = SLibGetCustomStorageIdxInMap(package, class)
          %assign bo.MemoryMapIdx = [-1, %<classIdx>, %<dataIdx>]
        %endif
      %endforeach
      %% Also process Local Block outputs, for function scoped storage classes
      %foreach boIdx = NumLocalBlockOutputs
        %assign bo = LocalBlockOutput[boIdx]
        %if !SLibOmitRecord(bo) && SLibIsLegacyStorageClassRecord(bo)
          %assign dataIdx = FcnAddCustomData(bo)
          %assign package = LibGetRTWInfoObjectPackage(bo)
          %assign class = LibGetCustomStorageClassName(bo)
          %assign classIdx = SLibGetCustomStorageIdxInMap(package, class)
          %assign bo.MemoryMapIdx = [-1, %<classIdx>, %<dataIdx>]
        %endif
      %endforeach
      %% After Mapping Explicit External Block Outputs, we now need to map
      %% Global block outputs as part of default mapping. Do this now.
      %foreach gboIdx = NumGlobalBlockOutputs
        %assign gbo = GlobalBlockOutput[gboIdx]
        %if !SLibOmitRecord(gbo) && SLibIsLegacyStorageClassRecord(gbo)
          %% If this is a model reference target and the VarGroup is from the
          %% base system, then skip it. We may get global block outputs here from
          %% signals feeding model reference root outports. These go into the root
          %% var group and then are thrown away.
          %if IsModelReferenceTarget()
            %assign varGroupIdx = gbo.VarGroupIdx[0]
            %assign sysIdx = SLibVarGroupSystemIdx(varGroupIdx)
            %if LibSystemIsRoot(System[sysIdx])
              %continue
            %endif
          %endif
           
          %assign dataIdx = FcnAddCustomData(gbo)
          %assign package = LibGetRTWInfoObjectPackage(gbo)
          %assign class = LibGetCustomStorageClassName(gbo)
          %assign classIdx = SLibGetCustomStorageIdxInMap(package, class)
          %assign gbo.MemoryMapIdx = [-1, %<classIdx>, %<dataIdx>]
        %endif
      %endforeach
    %endif
     
  %endwith %% BlockOutputs
   
  %assign ::CompiledModel.BlockOutputsMapped = 1
%endfunction
 
 
%%Function:FcnMapStateflowData===============================================
%%Abstract:
%%Stateflowmachineparenteddata.
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%
%function FcnMapStateflowData() void
   
  %if !::CompiledModel.ParametersMapped
    %assign errTxt = "Parameters must be mapped prior to Stateflow data."
    %<LibReportFatalError(errTxt)>
  %endif
   
  %assign sfInfo = FEVAL("rtwmaputil", ::CompiledModel.Name)
  %assign numData = (SIZE(sfInfo,1)-2)/4
  %foreach idx = numData
    %assign offset = (idx*4)+2
    %assign dataTypeName = sfInfo[offset+2]
     
    %if (dataTypeName != "fixpt") && (dataTypeName != "structure") && ...
      (dataTypeName != "enumerated")
      %% Skip Stateflow data that is of fixed-point or structure or enumerated
      %% type
      %assign topSysIdx = NumSystems-1
      %assign topSysCsIdx = [ %<topSysIdx>, -1]
      %createrecord /
      infoRec { /
        RecordType "MachineData"; /
        HasObject 0; /
        Name sfInfo[offset]; /
        Scope sfInfo[offset+1]; /
        DataType sfInfo[offset+2]; /
        Size sfInfo[offset+3]; /
        SysCsIdx topSysCsIdx /
      }
      %<FcnAddToModelParameters(infoRec)>
    %endif
  %endforeach
   
  %assign ::CompiledModel.StateflowDataMapped = 1
   
%endfunction
 
 
%%Function:FcnMapDWork=======================================================
%%Abstract:
%%MapDWorkstructurenotofcustomstorageclass.
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function FcnMapDWork() void
  %if !SLibModelDWorkStructIsEmpty()
    %%
    %% add dwork to global memory map
    %%
    %assign structIdx = FcnAddStructure(LibGetDWorkStruct())
    %assign varGroupIdx = ...
      FcnSysVarGroupIndex(System[GetBaseSystemIdx()], "DWork", 0)
    %<MapVarGroup(varGroupIdx, structIdx)>
  %endif
  %% DWork for standalone subsystems (if any)
  %if ::CompiledModel.StandaloneSSSupported == 1
    %assign baseSysIdx = GetBaseSystemIdx()
    %foreach varIdx = VarGroups.NumVarGroups
      %assign vGrp = VarGroups.VarGroup[varIdx]
      %if ( (vGrp.Category == "DWork") && ...
        (vGrp.ParentVarGroupIdx == -1) && ...
        (vGrp.SysIdx < baseSysIdx) )
        %%
        %% add dwork to global memory map
        %%
        %assign structIdx = FcnAddStructure(LibGetDWorkStruct())
        %assign varGroupIdx = ...
          FcnSysVarGroupIndex(System[vGrp.SysIdx], "DWork", 0)
        %<MapVarGroup(varGroupIdx, structIdx)>
      %endif
    %endforeach
  %endif
   
  %foreach dwIdx = DWorks.NumDWorks
    %assign dwRec = DWorks.DWork[dwIdx]
    %if !SLibOmitRecord(dwRec) && ...
      dwRec.StorageClass != "Auto" && dwRec.StorageClass != "Custom" && ...
      !(ISFIELD(dwRec, "DWorkForDimSize") && dwRec.DWorkForDimSize == 1)
      %%
      %% external dwork are unstructured data
      %%
      %assign dataIdx = FcnAddUnstructuredData(dwRec)
      %assign dwRec.MemoryMapIdx = [-1, -1, %<dataIdx>]
    %endif
  %endforeach
%endfunction
 
%%Function:FcnMapContStates================================================
%%Abstract:
%%MapContinuousstatesstructure.
%%TopTester:test/toolbox/simulink/blocks/tconcat.m
%%
%function FcnMapContStates() void
  %if !LibContStatesStructIsEmpty() || FcnSubsystemsHaveCStates()
     
    %% add ContStates StructuredData to global memory map
    %assign structIdx = FcnAddStructure("%<LibGetContinuousStateStruct()>")
    %assign struct = GlobalMemoryMap.StructuredData[structIdx]
     
    %% default System and instance indices
    %assign prevHStructSystemIdx = -1
    %assign prevHStructInstanceIdx = -1
     
    %% Loop through ContStates
    %foreach cStateIdx = ContStates.NumContStates
      %assign cStateRec = ContStates.ContState[cStateIdx]
      %assign varGroupIdx = cStateRec.VarGroupIdx[0]
      %assign varGroup = ::CompiledModel.VarGroups.VarGroup[varGroupIdx]
      %assign HStructSystemIdx = varGroup.SysIdx
      %assign HStructInstanceIdx = localGetHStructInstanceIdx(varGroup.InstanceIdx)
      %%
      %% Assert that Storage class is auto. Continuous states cannot be
      %% exported or imported. They cannot be of custom storage class.
      %%
      %assert cStateRec.StorageClass == "Auto"
      %% Add section to StructuredData, if the state is from a different
      %% system or is different instance of the same system
      %if (prevHStructSystemIdx != HStructSystemIdx) || ...
    (prevHStructInstanceIdx != HStructInstanceIdx)
    %% add new section
    %assign secIdx = FcnAddSection(struct, cStateRec)
    %assign section = struct.Section[secIdx]
    %assign prevHStructSystemIdx = HStructSystemIdx
    %assign prevHStructInstanceIdx = HStructInstanceIdx
      %endif
      %% Add new data to section and assign memory map index to the record
      %assign dataIdx = FcnAddStructuredData(struct, section, cStateRec)
      %assign cStateRec.MemoryMapIdx = [%<structIdx>, %<secIdx>, %<dataIdx>]
    %endforeach
   
  %endif %% !LibContStatesStructIsEmpty()
%endfunction
 
%%Function:FcnMapContStateDerivatives=======================================
%%Abstract:
%%MapContinuousstatesDerivativesstructure.
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants3.m
%%
%function FcnMapContStateDerivatives() void
  %if !(LibCStatesDerivStructIsEmpty()) || FcnSubsystemsHaveCDeriv()
     
    %% add ContStateDerivatives StructuredData to global memory map
    %assign structIdx = FcnAddStructure("StateDerivatives")
    %assign struct = GlobalMemoryMap.StructuredData[structIdx]
     
    %% default System and instance indices
    %assign prevHStructSystemIdx = -1
    %assign prevHStructInstanceIdx = -1
     
    %% Loop through ContStates. There is no ::CompiledModel.Derivatives records
    %% Note each ContState will have a corresponding derivative
    %%
    %foreach cStateIdx = ContStates.NumContStates
      %assign cStateRec = ContStates.ContState[cStateIdx]
      %assign varGroupIdx = cStateRec.VarGroupIdx[0]
      %assign varGroup = ::CompiledModel.VarGroups.VarGroup[varGroupIdx]
      %assign HStructSystemIdx = varGroup.SysIdx
      %assign HStructInstanceIdx = localGetHStructInstanceIdx(varGroup.InstanceIdx)
      %%
      %% Assert that Storage class is auto. Continuous states cannot be
      %% exported or imported. They cannot be of custom storage class.
      %%
      %assert cStateRec.StorageClass == "Auto"
      %% Add section to StructuredData, if the state is from a different
      %% system or is different instance of the same system
      %if (prevHStructSystemIdx != HStructSystemIdx) || ...
    (prevHStructInstanceIdx != HStructInstanceIdx)
    %% add new section
    %assign secIdx = FcnAddSection(struct, cStateRec)
    %assign section = struct.Section[secIdx]
    %assign prevHStructSystemIdx = HStructSystemIdx
    %assign prevHStructInstanceIdx = HStructInstanceIdx
      %endif
      %% Add new data to section and assign memory map index to the record
      %assign dataIdx = FcnAddStructuredData(struct, section, cStateRec)
      %assign cStateRec.DerivativeMemoryMapIdx = ...
    [%<structIdx>, %<secIdx>, %<dataIdx>]
    %endforeach
   
  %endif %% !(LibCStatesDerivStructIsEmpty())
%endfunction
 
 
%%Function:FcnMapCustomDWork=================================================
%%Abstract:
%%MapDWorkwithcustomstorageclass.
%%
%function FcnMapCustomDWork() void
  %foreach dwIdx = DWorks.NumDWorks
    %assign dwRec = DWorks.DWork[dwIdx]
     
    %if !SLibOmitRecord(dwRec) && SLibIsLegacyStorageClassRecord(dwRec)
      %assign dataIdx = FcnAddCustomData(dwRec)
      %assign package = LibGetRTWInfoObjectPackage(dwRec)
      %assign class = LibGetCustomStorageClassName(dwRec)
      %assign classIdx = SLibGetCustomStorageIdxInMap(package, class)
      %assign dwRec.MemoryMapIdx = [-1, %<classIdx>, %<dataIdx>]
    %endif
       
  %endforeach
%endfunction
 
%function FcnMapCustomZeroCrossings() void
  %foreach idx = ::CompiledModel.ZcRec.NumBlkZcRecs
    %assign blkZcRec = ::CompiledModel.ZcRec.BlkZcRec[idx]
    %foreach jdx = blkZcRec.NumZcSignalInfos
      %assign zcSignalInfo = blkZcRec.ZcSignalInfo[jdx]
     
      %if SLibIsLegacyStorageClassForDataRecord(zcSignalInfo)
        %assign dataIdx = FcnAddCustomData(zcSignalInfo)
        %assign package = LibGetRTWInfoObjectPackage(zcSignalInfo)
        %assign class = LibGetCustomStorageClassName(zcSignalInfo)
        %assign classIdx = SLibGetCustomStorageIdxInMap(package, class)
        %assign zcSignalInfo.MemoryMapIdx = [-1, %<classIdx>, %<dataIdx>]
      %endif
    %endforeach
  %endforeach
%endfunction
 
 
%%Function:FcnMapExternalInputs=============================================
%%Abstract:
%%MapExternalInputsstructure.
%%TopTester:test/toolbox/simulink/variants/codevariants/tcodevariants3.m
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortGecks.m
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%Toptetser:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function FcnMapExternalInputs() void
  %if !LibExternalInputsStructIsEmpty()
    %% add external inputs to global memory map
    %assign structIdx = FcnAddStructure(::tInput)
    %assign struct = GlobalMemoryMap.StructuredData[structIdx]
  %endif
   
  %assign prevComplex = -1
  %assign prevDataTypeIdx = -1
  %assign paddingRequired = TLC_FALSE
   
  %with ExternalInputs
    %foreach eiIdx = NumExternalInputs
      %assign ei = ExternalInput[eiIdx]
 
      %if ISFIELD(ei, "Inactive")
        %%Skip mapping always inactive root inports
        %% TopTester : test/toolbox/simulink/variants/inlineVariants/variantSource/systemtests/tVariantSource4.m -testspec:g1333943
        %continue
      %endif
 
      %% If this signal belongs to a coderDataGroupVarGroup, don't include it
      %% with the root inputs struct
      %if(SLibDataRecordIsInCoderGroup(ei))
        %continue
      %endif
 
      %assign slBaseTypeIdx = LibCGTypeSLBaseType(ei.CGTypeIdx)
      %assign slBaseTypeSize = LibGetDataTypeSLSizeFromId(slBaseTypeIdx)
      %if slBaseTypeSize == 0
        %% No need to map external inputs with empty size
         
        %continue
       
      %elseif ei.StorageClass == "Auto"
           
        %if IsModelReferenceTarget()
           
          %% Ignore external inputs. Only Canonical inputs will be mapped
          %continue
 
        %elseif SLibAutosarActive()
          %% Ignore external inputs.
          %continue
 
        %elseif (SLibFcnProtoCtrlActive() || GenerateClassInterface) && ...
                ei.RequiresGlobalAccess == "no"
 
          %% Ignore external inputs not requiring global access
          %continue
 
        %elseif MultiInstanceERTCode && !RootIOStructures
           
          %% external signals are passed as individual arguments.
          %% Map them as unstructured data
          %assign dataIdx = FcnAddUnstructuredData(ei)
          %assign ei.MemoryMapIdx = [-1, -1, %<dataIdx>]
         
        %elseif EXISTS(struct) && !ISEMPTY(struct)
           
          %% External Inputs are accessed as a part of global structure.
          %% it's in ExternalInputs structure, so look for transition
     
          %if (LibGetRecordIsComplex(ei) != prevComplex) || ...
            (LibGetRecordDataTypeId(ei) != prevDataTypeIdx) || ...
            LibIsStringDataType(prevDataTypeIdx) || ...
            paddingRequired
            %% add new section
            %assign secIdx = FcnAddSection(struct, ei)
            %assign section = struct.Section[secIdx]
            %assign prevComplex = LibGetRecordIsComplex(ei)
            %assign prevDataTypeIdx = LibGetRecordDataTypeId(ei)
          %endif
          %assign paddingRequired = (ei.Padding > 0) ? TLC_TRUE : TLC_FALSE
           
          %assign dataIdx = FcnAddStructuredData(struct, section, ei)
          %assign ei.MemoryMapIdx = [%<structIdx>, %<secIdx>, %<dataIdx>]
           
        %endif
                   
      %elseif ei.StorageClass != "Custom"
           
        %% external signals are unstructured data
         
        %assign dataIdx = FcnAddUnstructuredData(ei)
        %assign ei.MemoryMapIdx = [-1, -1, %<dataIdx>]
         
      %endif
             
    %endforeach
  %endwith
   
  %if IsModelReferenceTarget()
    %% For a model reference target, external inputs are the canonical
    %% inputs of the sub-model functions. Canonical inputs are passed
    %% via arguments to the function.
     
    %% Also, the sub-model does not know the identifier corresponding
    %% to the global address, it only knows the identifier corresponding
    %% to the function argument. This argument will be cached in the
    %% global memory map. Any application using global memory map during
    %% a model reference build, should run a initialize function (run-time)
    %% so that the function argument and the global signal identifier point
    %% to the same global address.
     
    %assign baseSysIdx = GetBaseSystemIdx()
    %with System[baseSysIdx].Interface
      %foreach ciIdx = NumCanonicalInputArgDefs
        %assign ci = CanonicalInputArgDef[ciIdx]
        %assign inputPortInfo = ci.SignalSrc
        %assign u_str_idx = IDNUM(inputPortInfo[0])
        %if (u_str_idx[0] != "U" && u_str_idx[0] != "M")
          %<LibReportFatalError("CI Error")>
        %endif
        %assign u_idx = u_str_idx[1]
        %assign ei = ::CompiledModel.ExternalInputs.ExternalInput[u_idx]
        %if (ei.StorageClass != "Auto")
          %<LibReportFatalError("CI Auto Error")>
        %endif
         
        %if (ei.TestPoint != "yes")
          %% The submodel's external input can be defined as global or local
          %% in the top model. Marking the input in the sub-model with a
          %% testpoint forces it to be a defined as a true global in the
          %% top-model. In other words, the testpoint back-propagates from
          %% the sub-model to the top-model.
          %continue
        %endif
          
        %assign isPtr = (LibGetRecordWidth(ci)>1 || ci.DeclareAsPointer == "yes")
        %if IsModelReferenceRTWTarget() && !isPtr
          %% Ignore fixed-size scalar root inputs passed by value
          %assert LibGetRecordWidth(ci) == 1
          %continue
        %endif
         
        %if GenerateClassInterface || SLibFcnProtoCtrlActive()
          %if ei.RequiresGlobalAccess == "yes"
            %assign errTxt = "External Input Record must not require " + ...
              "global access when generating a C++ class interface or Function " + ...
              "Prototype Control code"
            %<LibReportFatalError(errTxt)>
          %endif
          %% Ignore external inputs
          %continue
        %endif
         
        %assign mappingTestPoint = (IsModelReferenceSimTarget() && ei.TestPoint == "yes" && SLibGetCanIOIsVarDims(ci))
         
        %if (mappingTestPoint)
          %% ModelRefSimTarget signals are not logged if varDims
          %continue
        %endif
         
        %% Canonical inputs are mapped as unstructured data
        %assign currIdentifier = LibGetRecordIdentifier(ei)
        %<LibSetRecordIdentifier(ei, LibGetRecordIdentifier(ci))>
        %assign dataIdx = FcnAddUnstructuredData(ei)
        %assign ei.MemoryMapIdx = [-1, -1, %<dataIdx>]
        %<LibSetRecordIdentifier(ei, currIdentifier)>
 
        %if SLibGetCanIOIsVarDims(ci)
          %assign cdwIdx = SLibGetCanDimSizeDWIdxForArg(ci)
          %<SLibAccessArgHelper(CanonicalDWorkArgDef[cdwIdx],"","")>
        %endif
      %endforeach
    %endwith
  %endif
     
  %assign ::CompiledModel.ExternalInputsMapped = 1
   
%endfunction
 
%%Function:FcnMapCustomExternalInputs========================================
%%Abstract:
%%MapExternalInputswithcustomstorageclass
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%
%function FcnMapCustomExternalInputs() void
  %with ExternalInputs
    %foreach eiIdx = NumExternalInputs
      %assign ei = ExternalInput[eiIdx]
       
      %if SLibIsLegacyStorageClassRecord(ei)
    %assign dataIdx = FcnAddCustomData(ei)
    %assign package = LibGetRTWInfoObjectPackage(ei)
    %assign class = LibGetCustomStorageClassName(ei)
    %assign classIdx = SLibGetCustomStorageIdxInMap(package, class)
    %assign ei.MemoryMapIdx = [-1, %<classIdx>, %<dataIdx>]
      %endif
    %endforeach
  %endwith
     
  %assign ::CompiledModel.ExternalInputsMapped = 1
   
%endfunction
 
%%Function:FcnMapCustomExternalOutputs========================================
%%Abstract:
%%MapExternalOutputswithcustomstorageclass
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%
%function FcnMapCustomExternalOutputs() void
  %with ExternalOutputs
    %foreach eoIdx = NumExternalOutputs
      %assign eo = ExternalOutput[eoIdx]
       
      %if SLibIsLegacyStorageClassRecord(eo)
    %assign dataIdx = FcnAddCustomData(eo)
    %assign package = LibGetRTWInfoObjectPackage(eo)
    %assign class = LibGetCustomStorageClassName(eo)
    %assign classIdx = SLibGetCustomStorageIdxInMap(package, class)
    %assign eo.MemoryMapIdx = [-1, %<classIdx>, %<dataIdx>]
      %endif
    %endforeach
  %endwith
%endfunction
 
%%Function:FcnMapExternalOutputs=============================================
%%Abstract:
%%MapExternalOutputsstructure.
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%TopTester:test/toolbox/simulink/variants/variantBus/tVariantBusGecks.m
%%
%function FcnMapExternalOutputs() void
  %if !LibExternalOutputsStructIsEmpty()
    %% add external outputs to global memory map
    %assign structIdx = FcnAddStructure("%<LibGetExternalOutputStruct()>")
    %assign struct = GlobalMemoryMap.StructuredData[structIdx]
  %endif
 
  %assign prevComplex = -1
  %assign prevDataTypeIdx = -1
  %assign paddingRequired = TLC_FALSE
 
  %with ExternalOutputs
    %foreach eoIdx = NumExternalOutputs
      %assign eo = ExternalOutput[eoIdx]
      %% For inactive output ports, the externaloutput structure will be empty
      %% i.e LibExternalOutputsStructIsEmpty() will be true. Hence, we will not
      %% define define the variable 'struct' leading to errors.
      %% TopTester: test/toolbox/rtw/targets/ert/pil/modelblock/tsil_basicInlineVariant.m
      %if (ISFIELD(eo, "Inactive"))
      %continue
      %endif
      %assign sysIdx = eo.Block[0]
      %assign blkIdx = eo.Block[1]
      %assign oblock = System[sysIdx].Block[blkIdx]
      %assign ip = oblock.DataInputPort
         
      %% If this signal belongs to a coderDataGroupVarGroup, don't include it
      %% with the root output struct
      %if(SLibDataRecordIsInCoderGroup(eo))
        %continue
      %endif
 
      %if eo.StorageClass == "Auto"
        %if SLibExternalOutputIsVirtual(oblock)
          %continue
        %elseif SLibAutosarActive()
          %continue
        %elseif (SLibFcnProtoCtrlActive() || GenerateClassInterface) && ...
                eo.RequiresGlobalAccess == "no"
          %continue
        %endif
 
        %% look for transition
 
        %if (LibGetRecordIsComplex(ip) != prevComplex) || ...
              (LibGetRecordDataTypeId(ip) != prevDataTypeIdx) || ...
            LibIsStringDataType(prevDataTypeIdx) || ...
            paddingRequired
      %% add new section
      %assign secIdx = FcnAddSection(struct, eo)
      %assign section = struct.Section[secIdx]
      %assign prevComplex = LibGetRecordIsComplex(ip)
      %assign prevDataTypeIdx = LibGetRecordDataTypeId(ip)
        %endif
        %assign paddingRequired = (eo.Padding > 0) ? TLC_TRUE : TLC_FALSE
     
    %assign dataIdx = FcnAddStructuredData(struct, section, eo)
    %assign eo.MemoryMapIdx = [%<structIdx>, %<secIdx>, %<dataIdx>]
      %elseif eo.StorageClass != "Custom"
        %% external signals are unstructured data
        %assign dataIdx = FcnAddUnstructuredData(eo)
        %assign eo.MemoryMapIdx = [-1, -1, %<dataIdx>]
      %endif
 
      %<FcnAssignExternalOutputIdxToBlock(eo, eoIdx)>
    %endforeach
  %endwith
%endfunction
 
 
%%FunctionSLibGetCustomStorageIdxInMap=======================================
%%Abstract:
%%Returnindexofcustomstorageclass(-1ifdoesn'texist)frompackage
%%andname
%%
%function SLibGetCustomStorageIdxInMap(package, name)
  %assign gmm = ::CompiledModel.GlobalMemoryMap
  %if ISFIELD(gmm.CustomDataIndexHash, package)
    %if ISFIELD(gmm.CustomDataIndexHash.%<package>, name)
      %return gmm.CustomDataIndexHash.%<package>.%<name>
    %else
      %return -1
    %endif
  %else
    %return -1
  %endif
%endfunction
 
 
%%FunctionLibGetCustomStorageInMap===========================================
%%Abstract:
%%Returncustomstorageclass([]ifdoesn'texist)frompackageandname
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%
%function LibGetCustomStorageInMap(package, name)
  %assign gmm = ::CompiledModel.GlobalMemoryMap
  %if ISFIELD(gmm.CustomDataIndexHash, package)
    %if ISFIELD(gmm.CustomDataIndexHash.%<package>, name)
     %return gmm.CustomData[gmm.CustomDataIndexHash.%<package>.%<name>]
   %else
     %return []
   %endif
  %else
    %return []
  %endif
%endfunction
 
%%Function:FcnPostMapCleanup=================================================
%%Abstract:
%%RemovesMathWorksinternaluseonlyfieldsfromGlobalMemoryMap
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortFcnCall3.m
%%TopTester:test/toolbox/rtw/targets/ert/tcodevariants.m
%%
%function FcnPostMapCleanup() void
  %with GlobalMemoryMap
 
    %% remove OffsetCounter, SL_LogicalSrc, and SL_ExtModeType from each
    %% StructuredData Section
 
    %foreach structureIdx = NumStructuredData
      %assign structure = StructuredData[structureIdx]
      %with structure
    %foreach sectionIdx = NumSections
      %<REMOVEFIELD(Section[sectionIdx], "OffsetCounter")>
      %assign section = structure.Section[sectionIdx]
      %with section
        %foreach dataIdx = NumData
          %<REMOVEFIELD(Data[dataIdx], "SL_LogicalSrc")>
          %<REMOVEFIELD(Data[dataIdx], "SL_ExtModeType")>
        %endforeach
      %endwith
    %endforeach
      %endwith
    %endforeach
 
    %% remove InstanceCache and SignalInstanceCache from ModelParameters
 
    %<REMOVEFIELD(ModelParameters, "InstanceCache")>
    %<REMOVEFIELD(ModelParameters, "SignalInstanceCache")>
 
    %% There may not be any unstructured data
 
    %if UnstructuredData.NumData == 0
      %<REMOVEFIELD(GlobalMemoryMap, "UnstructuredData")>
      %<SETFIELD(GlobalMemoryMap, "NumUnstructuredData", 0)>
    %else
       
      %% remove SL_LogicalSrc and SL_ExtModeType from each
      %% UnstructuredData Section
 
      %if ISFIELD(GlobalMemoryMap,"UnstructuredData")
    %with UnstructuredData
      %foreach dataIdx = NumData
        %<REMOVEFIELD(Data[dataIdx], "SL_LogicalSrc")>
        %<REMOVEFIELD(Data[dataIdx], "SL_ExtModeType")>
      %endforeach
    %endwith
      %endif
    %endif
     
    %% remove SL_LogicalSrc and SL_ExtModeType from each custom data section
 
    %if ISFIELD(GlobalMemoryMap,"CustomData")
      %foreach customDataIdx = NumCustomData
    %with CustomData[customDataIdx]
    %foreach dataIdx = NumData
      %<REMOVEFIELD(Data[dataIdx], "SL_LogicalSrc")>
      %<REMOVEFIELD(Data[dataIdx], "SL_ExtModeType")>
    %endforeach
        %endwith
      %endforeach
    %endif
 
  %endwith
%endfunction
 
%%Function:FcnGetDWorkIdentifier=============================================
%%Abstract:
%%TheDWorkidentifierisalittletrickysincetheRIPWorkvectorsare
%%mappedintoDWork.RIPWorkhaveanRIPWorkDefinesnamingconvension,
%%inwhichcase,thenamedRIPWorkisaddedtotheDWorkidentifier.
%%TopTester:test/toolbox/rtw/targets/ert/model2model/cloneDetection/libraryPattern/tLibPatternGecks3.m
%%
%function FcnGetDWorkIdentifier(dwRec, accessSysIdx) void
  %assign cross = System[accessSysIdx].CrossNoArgFcnBound
  %assign id = SLibCG_GetVarGroupElementPath(dwRec.VarGroupIdx, ...
    accessSysIdx, cross)
  %assign optName = ""
  %if dwRec.SigSrc[0] >= 0 && dwRec.SigSrc[0] >= 0
    %assign block = System[dwRec.SigSrc[0]].Block[dwRec.SigSrc[2]]
    %with block
      %if (dwRec.Origin == "RWORK") && (NumRWorkDefines > 0)
        %assign optName = ".%"
      %elseif (dwRec.Origin == "IWORK") && (NumIWorkDefines > 0)
        %assign optName = ".%"
      %elseif (dwRec.Origin == "PWORK") && (NumPWorkDefines > 0)
        %assign optName = ".%"
      %endif
    %endwith
  %endif
  %return id + optName
%endfunction
 
%%Function:FcnGetDWorkWidth==================================================
%%Abstract:
%%TheDWorkwidthisalittletrickysincetheRIPWorkvectorsare
%%mappedintoDWork.
%%TopTester:test/toolbox/rtw/targets/ert/model2model/cloneDetection/libraryPattern/tLibPatternGecks3.m
%%
%function FcnGetDWorkWidth(dwRec) void
  %if dwRec.SigSrc[0] == -1 || dwRec.SigSrc[2] == -1
    %return SLibDWorkWidth(dwRec)
  %else
    %assign block = System[dwRec.SigSrc[0]].Block[dwRec.SigSrc[2]]
    %with block
      %if (dwRec.Origin == "RWORK") && (NumRWorkDefines > 0)
        %return RWorkDefine[0].Width
      %elseif (dwRec.Origin == "IWORK") && (NumIWorkDefines > 0)
        %return IWorkDefine[0].Width
      %elseif (dwRec.Origin == "PWORK") && (NumPWorkDefines > 0)
        %return PWorkDefine[0].Width
      %else
        %return SLibDWorkWidth(dwRec)
      %endif
    %endwith
  %endif
%endfunction
 
%%Function:FcnGetCStateIdentifier=============================================
%%Abstract:
%%
%function FcnGetCStateIdentifier(cStateRec, accessSysIdx) void
  %assign varGroupIdx = cStateRec.VarGroupIdx[0]
  %assign cStatePath = SLibCGIRVarGroupPath(varGroupIdx,accessSysIdx,TLC_FALSE)
  %assign id = "%<cStatePath>%<cStateRec.Identifier>"
     
  %return id
%endfunction
 
 
%%Function:FcnComputeSizeFromDims============================================
%%Abstract:
%%ReturnsthenominalsizeofanN-Dimensionalarray(i.e.,thisroutine
%%takeseverythingintoaccountexceptwordsize).
%%TopTester:test/toolbox/simulink/blocks/tmux_blkDialog.m
%%
%function FcnComputeSizeFromDims(dims,isComplex) void
  %assign nDims = SIZE(dims,1)
  %if nDims > 2
    %assign size = 1
    %foreach dimIdx = nDims
      %assign size = size * dims[dimIdx]
    %endforeach
    %assign size = size * (isComplex ? 2 : 1)
  %else
    %assign nRows = dims[0]
    %assign nCols = dims[1]
    %assign size = nRows*nCols * (isComplex ? 2 : 1)
  %endif
  %return CAST("Number", size)
%endfunction
 
 
%%=============================================================================
%%UtilitiesforaccessingGlobalMemoryMap
%%=============================================================================
 
%%Function:SLibGetMapStructData==============================================
%%Abstract:
%%ReturnstheparamsinthertPstructure,thesignalsinthertB
%%structure,ortheDWorksinthertDWorksstructurebasedonthe
%%inputargument-iftheyexist.
%%TopTester:test/toolbox/simulink/blocks/A/assignment/tassign_1.m
%%
%function SLibGetMapStructData(type) void
  %with GlobalMemoryMap
    %switch(type)
      %case "parameter"
    %assign name = "%<LibGetParametersStruct()>"
    %break
      %case "signal"
    %assign name = "%<LibGetBlockIOStruct()>"
    %break
      %case "dwork"
    %assign name = "%<LibGetDWorkStruct()>"
    %break
      %default
        %assert TLC_FALSE
    %break
    %endswitch
 
    %foreach structureIdx = NumStructuredData
      %assign structure = StructuredData[structureIdx]
      %if structure.Name == name
        %return structure
      %endif
    %endforeach
  %endwith
   
  %return %%return an empty record if no structured parameters
%endfunction
 
 
%%Function:SLibGetParameterMapNumDataSections================================
%%Abstract:
%%ThisfunctionisawrapperandcallsSLibGetMapNumDataSections()with
%%"parameter"typeargument.
%%
%function SLibGetParameterMapNumDataSections() void
  %return %<SLibGetMapNumDataSections("parameter")>
%endfunction
 
 
%%Function:SLibGetBlockIOMapNumDataSections==================================
%%Abstract:
%%ThisfunctionisawrapperandcallsSLibGetMapNumDataSections()with
%%"signal"and"dwork"typearguments.Thereturnedvaluesareadded
%%togetherandreturnedtothecaller.TheBlockIOdatatypetranstable
%%consistsofsignalsanddwork,sothetotalnumberofelementsisthe
%%sumofthedatasectionsforeach.
%%
%function SLibGetBlockIOMapNumDataSections() void
  %return SLibGetMapNumDataSections("signal") + ...
  SLibGetMapNumDataSections("dwork") + ...
  SLibGetMapNumDataSections("coderGroup")
%endfunction
 
 
%%Function:SLibGetMapNumDataSections=========================================
%%Abstract:
%%Returnsthetotalnumberofdatasectionsbyaddingthesectionsinthe
%%structured,unstructured,andcustomclasses.
%%TopTester:test/toolbox/simulink/variants/inlineVariants/simulinkFunction/tVariantSimulinkFunctionAutoInherit.m
%%TopTester:test/toolbox/simulink/blocks/lib_MathOperations/Gain/rtw/tNumerics_Gainblk_blas_misc.m
%%
%function SLibGetMapNumDataSections(type) void
  %assign isCoderGroupType = (type == "coderGroup")
  %assign nStructured = 0
  %with GlobalMemoryMap
     
    %%
    %% Get numSections in structured area.
    %%
    %if !isCoderGroupType
      %assign structuredData = SLibGetMapStructData(type)
      %if EXISTS(structuredData.NumSections)
        %assign nStructured = nStructured + structuredData.NumSections
      %endif
    %else %%isCoderGroupType == true
      %foreach groupIdx = ::CompiledModel.NumCoderDataGroups
        %assign group = ::CompiledModel.CoderDataGroup[groupIdx]
        %if SLibCoderGroupPackageAsStruct(group) && SLibGetRootVarGroupIdxForCoderGroup(group) >= 0
          %assign varGroup = SLibVarGroupForCoderGroup(group)
          %foreach structureIdx = NumStructuredData
            %assign structure = StructuredData[structureIdx]
            %if structure.Name == varGroup.Name && EXISTS(structure.NumSections)
              %assign nStructured = nStructured + structure.NumSections
            %endif
          %endforeach
        %endif
      %endforeach
    %endif
     
    %%
    %% Count number of non-auto storage classes (each one is a 'section')
    %%
    %assign nNonAuto = 0
    %if ISFIELD(GlobalMemoryMap,"UnstructuredData")
      %assign nData = UnstructuredData.NumData
       
      %foreach dataIdx = nData
    %assign data = UnstructuredData.Data[dataIdx]
    %if data.SL_ExtModeType == type
      %% Any data record without the SL_LogicalSrc field does not
      %% correspond to an element of the Simulink BIO or Aggregate
      %% Parameter tables and can not be included in the data type
      %% tranistion table or the target data map file. An example
      %% is a signal declared as an "exported global". The function
      %% FcnDumpExtModeHostMapBody() in extmodemaplib.ttlc performs
      %% the same check to exclude these records from being written
      %% to the target data map file.
      %if ISFIELD(data,"SL_LogicalSrc")
        %assign nNonAuto = nNonAuto + 1
      %endif
    %endif
      %endforeach
    %endif
     
    %%
    %% Count number of custom storage classes (each one is a 'section')
    %%
    %assign nCustom = 0
    %if ISFIELD(GlobalMemoryMap,"CustomData")
      %assign nDataRecs = NumCustomData
       
      %foreach dataRecIdx = nDataRecs
    %assign customDataRec = CustomData[dataRecIdx]
    %assign nData = customDataRec.NumData
       
      %foreach dataIdx = nData
      %if nData == 1
        %assign data = customDataRec.Data
      %else
        %assign data = customDataRec.Data[dataIdx]
      %endif
     
      %if data.SL_ExtModeType == type && data.NumDimensions != -1
        %% Any data record without the SL_LogicalSrc field does not
        %% correspond to an element of the Simulink BIO or Aggregate
        %% Parameter tables and can not be included in the data type
        %% tranistion table or the target data map file. An example
        %% is a signal declared as an "exported global". The function
        %% FcnDumpExtModeHostMapBody() in extmodemaplib.ttlc performs
        %% the same check to exclude these records from being written
        %% to the target data map file.
        %if ISFIELD(data,"SL_LogicalSrc")
          %assign nCustom = nCustom + 1
        %endif
      %endif
    %endforeach
     
      %endforeach
       
    %endif
     
  %endwith
   
  %return nStructured + nNonAuto + nCustom
%endfunction
 
%%Function:FcnGetGlobalMemoryMapData=========================================
%%Abstract:
%%ReturnspointertoGlobalMemoryMapdatareferredtobyrecord
%%(record=RecordcontainingMemoryMapIdx)
%%-MemoryMapIdx[0]=StructureIdx(-1ifdataunavailable)
%%-MemoryMapIdx[1]=SectionIdx(-1ifunstructureddata)
%%-MemoryMapIdx[2]=DataIdx
%%
%%ReturnsstringifGlobalMemoryMapdataisnotavailable.
%%TopTester:test/toolbox/simulink/variants/tVariantGecks2.m
%%
%function FcnGetGlobalMemoryMapData(record)
%with record
  %if !ISFIELD(record,"MemoryMapIdx")
    %assign globalMemoryMapData = "No_MemoryMapIdx"
  %elseif MemoryMapIdx[2] == -1/
    %% Data is unavailable (reused signal)
    %assign globalMemoryMapData = "MemoryReused"
  %elseif MemoryMapIdx[1] == -1/
    %% Unstructured Data
    %assign dataIdx = MemoryMapIdx[2]
    %assign globalMemoryMapData = ...
            GlobalMemoryMap.UnstructuredData.Data[dataIdx]
  %elseif MemoryMapIdx[0] == -1/
    %% found a custom storage class
    %assign classIdx = MemoryMapIdx[1]
    %assign dataIdx = MemoryMapIdx[2]
    %assign globalMemoryMapData = ...
            GlobalMemoryMap.CustomData[classIdx].Data[dataIdx]
  %else /
    %% Structured data
    %assign structIdx = MemoryMapIdx[0]
    %assign sectionIdx = MemoryMapIdx[1]
    %assign dataIdx = MemoryMapIdx[2]
    %assign globalMemoryMapData = ...
            GlobalMemoryMap.StructuredData[structIdx].Section[sectionIdx].Data[dataIdx]
  %endif
%endwith
%return globalMemoryMapData
%endfunction
 
%%DocFunction{OtherUsefulFunctions}:LibGetGlobalMemoryMapData==============
%%Abstract:
%%ReturnspointertoGlobalMemoryMapdatareferredtobyrecord
%%(record=RecordcontainingMemoryMapIdx)
%%-MemoryMapIdx[0]=StructureIdx(-1ifdataunavailable)
%%-MemoryMapIdx[1]=SectionIdx(-1ifunstructureddata)
%%-MemoryMapIdx[2]=DataIdx
%%
%%ReturnsstringifGlobalMemoryMapdataisnotavailable.
%%
%function LibGetGlobalMemoryMapData(record)
  %return FcnGetGlobalMemoryMapData(record)
%endfunction
 
%%Function:FcnGetGlobalMemoryMapSection======================================
%%Abstract:
%%ReturnspointertoGlobalMemoryMapsectionreferredtobyrecord
%%(record=RecordcontainingMemoryMapIdx)
%%-MemoryMapIdx[0]=StructureIdx(-1ifdataunavailable)
%%-MemoryMapIdx[1]=SectionIdx(-1ifunstructureddata)
%%-MemoryMapIdx[2]=DataIdx
%%ReturnsstringifGlobalMemoryMapsectionisnotavailable.
%%TopTester:test/toolbox/simulink/variants/tVariantGecks2.m
%%
%function FcnGetGlobalMemoryMapSection(record)
%with record
  %if !ISFIELD(record,"MemoryMapIdx")
    %assign globalMemoryMapSection = "No_MemoryMapIdx"
  %elseif MemoryMapIdx[2] == -1/
    %% Data is unavailable (reused signal)
    %assign globalMemoryMapSection = "MemoryReused"
  %elseif MemoryMapIdx[1] == -1/
    %% Unstructured Data
    %assign globalMemoryMapSection = "Unstructured"
  %elseif MemoryMapIdx[0] == -1/
    %% Unstructured Data
    %assign globalMemoryMapSection = "Custom"
  %else /
    %% Structured data
    %assign structIdx = MemoryMapIdx[0]
    %assign sectionIdx = MemoryMapIdx[1]
    %assign globalMemoryMapSection = ...
            GlobalMemoryMap.StructuredData[structIdx].Section[sectionIdx]
  %endif
%endwith
%return globalMemoryMapSection
%endfunction
 
%function BlockIsStateflowSFunction(block) void
  %assign blkIsStateflow = TLC_FALSE
  %if block.Type == "S-Function"
    %if block.ParamSettings.FunctionName == "stateflow"
      %assign blkIsStateflow = TLC_TRUE
    %endif
  %endif
  %return blkIsStateflow
%endfunction
 
%%Function:FcnMapDataGroups=============================================
%%Abstract:
%%Thisfunctioncreatesamapofalluser-defineddatagroups.
%%TopTester:test/toolbox/simulink/variants/CondExecutedVSS/tContPortGecks.m
%%
%function FcnMapDataGroups() void
  %foreach idx = ::CompiledModel.NumCoderDataGroups
    %assign group = ::CompiledModel.CoderDataGroup[idx]
 
    %if group.IsLegacyStorageClass || SLibIsAutosarPIMCoderGroup(group)
      %continue
    %endif
 
    %% Skip this if it's a parameter group and we're not mapping parameters
    %if SLibDataGroupStaticInit(group) && !MapParameters
      %continue
    %endif
 
    %% Skip this if it's not a parameter group and we're not mapping DWorks
    %% or BlockOutputs (or Root I/O)
    %if !SLibDataGroupStaticInit(group) && ...
        !(MapDWork || MapBlockOutputs || MapExternalInputs || MapExternalOutputs)
      %continue
    %endif
 
    %assign groupName = group.Name
 
    %if SLibCoderGroupPackageAsStruct(group)
      %assign groupToken = "CoderDataGroup" + groupName
      %assign structIdx = FcnAddStructure(LibGetCoderDataGroupStruct(group))
      %assign varGroupIdx = ...
        FcnSysVarGroupIndex(System[GetBaseSystemIdx()], groupToken, 0)
      %<MapVarGroup(varGroupIdx, structIdx)>
    %else
      %% For each var group element, add unstructured data. We need to get the record
      %% associated with each var group element
      %assign varGroupIdx = SLibGetRootVarGroupIdxForCoderGroup(group)
      %foreach elemIdx = SLibVarGroupNumElements(varGroupIdx)
        %assign element = SLibVarGroupElementSource(varGroupIdx, elemIdx)
        %assign idnum = IDNUM(element)
        %if idnum[0] == "VG" && SLibVarGroupIsStruct(idnum[1])
          %% We may have a nested vargroup that's packaged as a struct
          %assign structName = ::CompiledModel.VarGroups.VarGroup[idnum[1]].Name
          %assign structIdx = FcnAddStructure(structName)
          %<MapVarGroup(idnum[1], structIdx)>
        %elseif idnum[0] != "PCDG" && idnum[0] != "ZE"
          %% We don't have coder group references or zero-crossing in global memory map. Skip
          %% for now.
          %assign dataRec = SLibGetDataRecForVarGroupMember(idnum[0], idnum[1])
          %assign dataIdx = FcnAddUnstructuredData(dataRec)
            %assign dataRec.MemoryMapIdx = [-1, -1, %<dataIdx>]
 
          %% Special handling for outports
          %if idnum[0] == "Y"
            %<FcnAssignExternalOutputIdxToBlock(dataRec, idnum[1])>
          %endif
        %endif
      %endforeach
    %endif
  %endforeach
%endfunction
 
 
%endif %% _GLOBALMAPLIB_
 
%%[EOF]globalmaplib.tlc