Treat array variables during Cpp code generation, ticket:5110

Belonging to [master]:
  - #2679

Author: rfranke

Compiler/Template/CodegenCpp.tpl

@@ -8052,6 +8052,15 @@ template memberVariableInitialize2(SimVar simVar, HashTableCrIListArray.HashTabl
               getSimVars()->init<%type%>AliasArray(LIST_OF <%arrayIndices%> LIST_END, <%arrayName%>_ref_data);
               <%arrayName%> = RefArrayDim<%dims%><<%typeString%>, <%arrayextentDims(name, v.numArrayElement)%>>(<%arrayName%>_ref_data);
               >>
+    /* newInst with arrays */
+    case v as SIMVAR(type_ = T_ARRAY()) then
+      let& dims = buffer "" /*BUFD*/
+      let varName = arraycref2(name, dims)
+      let typeString = expTypeShort(type_)
+      let arrayHeadIdx = listHead(SimCodeUtil.getVarIndexListByMapping(varToArrayIndexMapping,name,true,indexForUndefinedReferences))
+       <<
+       <%varName%> = StatArrayDim<%listLength(v.numArrayElement)%><<%typeString%>, <%List.lastN(v.numArrayElement, listLength(v.numArrayElement));separator=","%>, true>(&_pointerTo<%type%>Vars[<%arrayHeadIdx%>]);
+       >>
    /*special case for variables that marked as array but are not arrays */
     case SIMVAR(numArrayElement=_::_) then
 
@@ -8310,6 +8319,14 @@ template memberVariableDefine2(SimVar simVar, HashTableCrIListArray.HashTable va
           <<
           RefArrayDim<%dims%><<%typeString%>, <%array_dimensions%>> <%arrayName%>;
           >>
+    /* newInst with arrays */
+    case v as SIMVAR(type_ = T_ARRAY()) then
+      let& dims = buffer "" /*BUFD*/
+      let varName = arraycref2(name, dims)
+      let typeString = expTypeShort(type_)
+      <<
+      StatArrayDim<%listLength(v.numArrayElement)%><<%typeString%>, <%List.lastN(v.numArrayElement, listLength(v.numArrayElement));separator=","%>, <%createRefVar%>> <%varName%>;
+      >>
    /*special case for variables that marked as array but are not arrays */
     case SIMVAR(numArrayElement=_::_) then
       let& dims = buffer "" /*BUFD*/
@@ -9446,22 +9463,16 @@ template initValst(Text &varDecls, Text type, list<SimVar> varsLst, SimCode simC
      let crefStr = cref1(sv.name,simCode , &extraFuncs , &extraFuncsDecl,  extraFuncsNamespace,context,varDeclsCref, stateDerVectorName, useFlatArrayNotation)
      match initialValue
       case SOME(v) then
-        match daeExp(v, contextOther, &preExp, &varDecls,simCode , &extraFuncs , &extraFuncsDecl, extraFuncsNamespace, stateDerVectorName, useFlatArrayNotation)
-          case vStr as "0"
-          case vStr as "0.0"
-          case vStr as "(0)" then
-          '<%preExp%>
-           SystemDefaultImplementation::set<%type%>StartValue(<%crefStr%>,<%vStr%>);'
-          case vStr as "" then
-          '<%preExp%>
-           SystemDefaultImplementation::set<%type%>StartValue(<%crefStr%>,<%vStr%>);'
-          case vStr then
-          '<%preExp%>
-           SystemDefaultImplementation::set<%type%>StartValue(<%crefStr%>,<%vStr%>);'
-        end match
+        let vStr = daeExp(v, contextOther, &preExp, &varDecls,simCode , &extraFuncs , &extraFuncsDecl, extraFuncsNamespace, stateDerVectorName, useFlatArrayNotation)
+        <<
+        <%preExp%>
+        SystemDefaultImplementation::set<%type%>StartValue(<%crefStr%>, <%vStr%>);
+        >>
       else
-        '<%preExp%>
-         SystemDefaultImplementation::set<%type%>StartValue(<%crefStr%>,<%startValue(sv.type_)%>);'
+        <<
+        <%preExp%>
+        SystemDefaultImplementation::set<%type%>StartValue(<%crefStr%>, <%startValue(sv.type_)%>);
+        >>
       ;separator="\n")
   else
     (varsLst |> sv as SIMVAR(__) =>
@@ -9489,7 +9500,8 @@ template startValue(DAE.Type ty)
   case ty as T_REAL(__) then '0.0'
   case ty as T_BOOL(__) then 'false'
   case ty as T_STRING(__) then '"empty"'
-   case ty as T_ENUMERATION(__) then '0'
+  case ty as T_ENUMERATION(__) then '0'
+  case ty as T_ARRAY(ty = elty) then startValue(elty)
   else ""
 end startValue;
 

SimulationRuntime/cpp/Core/System/SystemDefaultImplementation.cpp

@@ -634,48 +634,112 @@ string& SystemDefaultImplementation::getStringStartValue(string& var)
   return _string_start_values.getGetStartValue(var);
 }
 
-void SystemDefaultImplementation::setRealStartValue(double& var,double val)
+void SystemDefaultImplementation::setRealStartValue(double& var, double val, bool overwriteOldValue)
 {
-  setRealStartValue(var,val,false);
+  var = val;
+  _real_start_values.setStartValue(var, val, overwriteOldValue);
 }
 
-void SystemDefaultImplementation::setRealStartValue(double& var,double val,bool overwriteOldValue)
+void SystemDefaultImplementation::setRealStartValue(BaseArray<double>& avar, double val, bool overwriteOldValue)
 {
-  var=val;
-  _real_start_values.setStartValue(var,val,overwriteOldValue);
+  double *varp = avar.getData();
+  size_t nel = avar.getNumElems();
+  for (size_t i = 0; i < nel; varp++, i++) {
+    *varp = val;
+    _real_start_values.setStartValue(*varp, val, overwriteOldValue);
+  }
+}
+
+void SystemDefaultImplementation::setRealStartValue(BaseArray<double>& avar, const BaseArray<double>& aval, bool overwriteOldValue)
+{
+  double *varp = avar.getData();
+  const double *valp = aval.getData();
+  size_t nel = avar.getNumElems();
+  for (size_t i = 0; i < nel; varp++, valp++, i++) {
+    *varp = *valp;
+    _real_start_values.setStartValue(*varp, *valp, overwriteOldValue);
+  }
+}
+
+void SystemDefaultImplementation::setBoolStartValue(bool& var, bool val, bool overwriteOldValue)
+{
+  var = val;
+  _bool_start_values.setStartValue(var, val, overwriteOldValue);
+}
+
+void SystemDefaultImplementation::setBoolStartValue(BaseArray<bool>& avar, bool val, bool overwriteOldValue)
+{
+  bool *varp = avar.getData();
+  size_t nel = avar.getNumElems();
+  for (size_t i = 0; i < nel; varp++, i++) {
+    *varp = val;
+    _bool_start_values.setStartValue(*varp, val, overwriteOldValue);
+  }
+}
+
+void SystemDefaultImplementation::setBoolStartValue(BaseArray<bool>& avar, const BaseArray<bool>& aval, bool overwriteOldValue)
+{
+  bool *varp = avar.getData();
+  const bool *valp = aval.getData();
+  size_t nel = avar.getNumElems();
+  for (size_t i = 0; i < nel; varp++, valp++, i++) {
+    *varp = *valp;
+    _bool_start_values.setStartValue(*varp, *valp, overwriteOldValue);
+  }
 }
 
-void SystemDefaultImplementation::setBoolStartValue(bool& var,bool val)
+void SystemDefaultImplementation::setIntStartValue(int& var, int val, bool overwriteOldValue)
 {
-  setBoolStartValue(var,val,false);
+  var = val;
+  _int_start_values.setStartValue(var, val, overwriteOldValue);
 }
 
-void SystemDefaultImplementation::setBoolStartValue(bool& var,bool val,bool overwriteOldValue)
+void SystemDefaultImplementation::setIntStartValue(BaseArray<int>& avar, int val, bool overwriteOldValue)
 {
-  var=val;
-  _bool_start_values.setStartValue(var,val,overwriteOldValue);
+  int *varp = avar.getData();
+  size_t nel = avar.getNumElems();
+  for (size_t i = 0; i < nel; varp++, i++) {
+    *varp = val;
+    _int_start_values.setStartValue(*varp, val, overwriteOldValue);
+  }
 }
 
-void SystemDefaultImplementation::setIntStartValue(int& var,int val)
+void SystemDefaultImplementation::setIntStartValue(BaseArray<int>& avar, const BaseArray<int>& aval, bool overwriteOldValue)
 {
-  setIntStartValue(var,val,false);
+  int *varp = avar.getData();
+  const int *valp = aval.getData();
+  size_t nel = avar.getNumElems();
+  for (size_t i = 0; i < nel; varp++, valp++, i++) {
+    *varp = *valp;
+    _int_start_values.setStartValue(*varp, *valp, overwriteOldValue);
+  }
 }
 
-void SystemDefaultImplementation::setIntStartValue(int& var,int val,bool overwriteOldValue)
+void SystemDefaultImplementation::setStringStartValue(string& var, string val, bool overwriteOldValue)
 {
-  var=val;
-  _int_start_values.setStartValue(var,val,overwriteOldValue);
+  var = val;
+  _string_start_values.setStartValue(var, val, overwriteOldValue);
 }
 
-void SystemDefaultImplementation::setStringStartValue(string& var,string val)
+void SystemDefaultImplementation::setStringStartValue(BaseArray<string>& avar, string val, bool overwriteOldValue)
 {
-  setStringStartValue(var,val,false);
+  string *varp = avar.getData();
+  size_t nel = avar.getNumElems();
+  for (size_t i = 0; i < nel; varp++, i++) {
+    *varp = val;
+    _string_start_values.setStartValue(*varp, val, overwriteOldValue);
+  }
 }
 
-void SystemDefaultImplementation::setStringStartValue(string& var,string val,bool overwriteOldValue)
+void SystemDefaultImplementation::setStringStartValue(BaseArray<string>& avar, const BaseArray<string>& aval, bool overwriteOldValue)
 {
-  var=val;
-  _string_start_values.setStartValue(var,val,overwriteOldValue);
+  string *varp = avar.getData();
+  const string *valp = aval.getData();
+  size_t nel = avar.getNumElems();
+  for (size_t i = 0; i < nel; varp++, valp++, i++) {
+    *varp = *valp;
+    _string_start_values.setStartValue(*varp, *valp, overwriteOldValue);
+  }
 }
 
 /**

SimulationRuntime/cpp/Include/Core/System/SystemDefaultImplementation.h

@@ -146,14 +146,18 @@ class BOOST_EXTENSION_SYSTEM_DECL SystemDefaultImplementation
   virtual bool& getBoolStartValue(bool& var);
   virtual int& getIntStartValue(int& var);
   virtual string& getStringStartValue(string& var);
-  virtual void setRealStartValue(double& var,double val);
-  virtual void setRealStartValue(double& var,double val,bool overwriteOldValue);
-  virtual void setBoolStartValue(bool& var,bool val);
-  virtual void setBoolStartValue(bool& var,bool val,bool overwriteOldValue);
-  virtual void setIntStartValue(int& var,int val);
-  virtual void setIntStartValue(int& var,int val,bool overwriteOldValue);
-  virtual void setStringStartValue(string& var,string val);
-  virtual void setStringStartValue(string& var,string val,bool overwriteOldValue);
+  virtual void setRealStartValue(double& var, double val, bool overwriteOldValue = false);
+  virtual void setRealStartValue(BaseArray<double>& avar, double val, bool overwriteOldValue = false);
+  virtual void setRealStartValue(BaseArray<double>& avar, const BaseArray<double>& aval, bool overwriteOldValue = false);
+  virtual void setBoolStartValue(bool& var, bool val, bool overwriteOldValue = false);
+  virtual void setBoolStartValue(BaseArray<bool>& avar, bool val, bool overwriteOldValue = false);
+  virtual void setBoolStartValue(BaseArray<bool>& avar, const BaseArray<bool>& aval, bool overwriteOldValue = false);
+  virtual void setIntStartValue(int& var,int val, bool overwriteOldValue = false);
+  virtual void setIntStartValue(BaseArray<int>& avar, int val, bool overwriteOldValue = false);
+  virtual void setIntStartValue(BaseArray<int>& avar, const BaseArray<int>& aval, bool overwriteOldValue = false);
+  virtual void setStringStartValue(string& var, string val, bool overwriteOldValue = false);
+  virtual void setStringStartValue(BaseArray<string>& avar, string val, bool overwriteOldValue = true);
+  virtual void setStringStartValue(BaseArray<string>& avar, const BaseArray<string>& aval, bool overwriteOldValue = true);
 protected:
     void Assert(bool cond, const string& msg);
     void Terminate(string msg);