- BackEnd refactoring: Now uses list of equation-systems instead of o…

…nly one - No optimization module, etc can handle this yet (only lists of length=1), but this will change soon enough git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@9652 f25d12d1-65f4-0310-ae8a-bbce733d8d8e
OpenModelica · Aug 18, 2011 · 4eac2fb · 4eac2fb
1 parent b0a15bc
commit 4eac2fb
Show file tree

Hide file tree

Showing 15 changed files with 216 additions and 216 deletions.
diff --git a/Compiler/BackEnd/BackendDAE.mo b/Compiler/BackEnd/BackendDAE.mo
@@ -239,7 +239,7 @@ uniontype BackendDAE "THE LOWERED DAE consist of variables and equations. The va
 
 end BackendDAE;
 
-type EqSystems = EqSystem "TODO: Make this a list in the future";
+type EqSystems = list<EqSystem> "NOTE: BackEnd does not yet support lists with different size than 1 everywhere (anywhere)";
 
 uniontype EqSystem "An independent system of equations (and their corresponding variables)"
   record EQSYSTEM

diff --git a/Compiler/BackEnd/BackendDAECreate.mo b/Compiler/BackEnd/BackendDAECreate.mo
@@ -135,7 +135,7 @@ algorithm
   algarr := listArray(algs);
   einfo := Inline.inlineEventInfo(BackendDAE.EVENT_INFO(whenclauses_1,{}),(SOME(functionTree),{DAE.NORM_INLINE()}));
   aliasVars := BackendDAEUtil.emptyAliasVariables();
-  outBackendDAE := BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_1,eqnarr,ieqnarr),knvars,extVars,aliasVars,reqnarr,arr_md_eqns,algarr,einfo,extObjCls);
+  outBackendDAE := BackendDAE.DAE(BackendDAE.EQSYSTEM(vars_1,eqnarr,ieqnarr)::{},knvars,extVars,aliasVars,reqnarr,arr_md_eqns,algarr,einfo,extObjCls);
   BackendDAEUtil.checkBackendDAEWithErrorMsg(outBackendDAE);
 end lower;
 
@@ -2591,14 +2591,14 @@ algorithm
       array<DAE.Algorithm> algorithms,algorithms1;
       BackendDAE.EventInfo einfo;
       BackendDAE.ExternalObjectClasses eoc;
-    case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,inieqns),knvars,exobj,av,remeqns,arreqns,algorithms,einfo,eoc),funcs,m,mT)
+    case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,inieqns)::{},knvars,exobj,av,remeqns,arreqns,algorithms,einfo,eoc),funcs,m,mT)
       equation
         (eqns1,(vars1,_)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(eqns,traverserexpandDerEquation,(vars,funcs));
         (inieqns1,(vars2,_)) = BackendEquation.traverseBackendDAEEqnsWithUpdate(inieqns,traverserexpandDerEquation,(vars1,funcs));
         (arreqns1,(vars3,_)) = BackendDAEUtil.traverseBackendDAEArrayNoCopyWithUpdate(arreqns,traverserexpandDerExp,BackendEquation.traverseBackendDAEExpsArrayEqnWithUpdate,1,arrayLength(arreqns),(vars2,funcs));
         (algorithms1,(vars4,_)) = BackendDAEUtil.traverseBackendDAEArrayNoCopyWithUpdate(algorithms,traverserexpandDerExp,BackendEquation.traverseBackendDAEExpsAlgortihmWithUpdate,1,arrayLength(algorithms),(vars3,funcs));
       then
-        (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars4,eqns1,inieqns1),knvars,exobj,av,remeqns,arreqns1,algorithms1,einfo,eoc),m,mT);
+        (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars4,eqns1,inieqns1)::{},knvars,exobj,av,remeqns,arreqns1,algorithms1,einfo,eoc),m,mT);
   end match;
 end expandDerOperator;
 
@@ -2904,7 +2904,7 @@ algorithm
       list<DAE.Algorithm> algs_lst,algs_lst1;
       list<BackendDAE.ZeroCrossing> zero_crossings;
       BackendDAE.EqSystems eqs;
-    case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,inieqns),knvars,exobj,av,remeqns,arreqns,algorithms,einfo as BackendDAE.EVENT_INFO(whenClauseLst=whenclauses),eoc))
+    case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,inieqns)::{},knvars,exobj,av,remeqns,arreqns,algorithms,einfo as BackendDAE.EVENT_INFO(whenClauseLst=whenclauses),eoc))
       equation
         eqs_lst = BackendDAEUtil.equationList(eqns);
         arreqns_lst = arrayList(arreqns);
@@ -2915,7 +2915,7 @@ algorithm
         algorithms1 = listArray(algs_lst1);
         einfo1 = BackendDAE.EVENT_INFO(whenclauses1,zero_crossings);
       then
-        (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns1,inieqns),knvars,exobj,av,remeqns,arreqns1,algorithms1,einfo1,eoc));
+        (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns1,inieqns)::{},knvars,exobj,av,remeqns,arreqns1,algorithms1,einfo1,eoc));
   end match;
 end findZeroCrossings;
 
@@ -3589,7 +3589,7 @@ algorithm
       list<list<Integer>> zcEqns;
       list<Integer> wcEqns;
       BackendDAE.EquationArray eqnArr;
-    case (BackendDAE.DAE(eventInfo=BackendDAE.EVENT_INFO(zeroCrossingLst = zcLst),eqs=BackendDAE.EQSYSTEM(orderedEqs=eqnArr))) 
+    case (BackendDAE.DAE(eventInfo=BackendDAE.EVENT_INFO(zeroCrossingLst = zcLst),eqs=BackendDAE.EQSYSTEM(orderedEqs=eqnArr)::{})) 
       equation
         zcEqns = Util.listMap(zcLst,zeroCrossingEquations);
         wcEqns = whenEquationsIndices(eqnArr);

diff --git a/Compiler/BackEnd/BackendDAEOptimize.mo b/Compiler/BackEnd/BackendDAEOptimize.mo
diff --git a/Compiler/BackEnd/BackendDAETransform.mo b/Compiler/BackEnd/BackendDAETransform.mo
diff --git a/Compiler/BackEnd/BackendDAEUtil.mo b/Compiler/BackEnd/BackendDAEUtil.mo
@@ -216,7 +216,7 @@ algorithm
       list<tuple<DAE.Exp,list<DAE.ComponentRef>>> expcrefs,expcrefs1,expcrefs2,expcrefs3,expcrefs4,expcrefs5,expcrefs7;
       list<BackendDAE.Equation> wrongEqns,wrongEqns1,wrongEqns2;
 
-    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars1,initialEqs = ieqns,orderedEqs = eqns),knownVars = vars2,removedEqs = reqns,
+    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars1,initialEqs = ieqns,orderedEqs = eqns)::{},knownVars = vars2,removedEqs = reqns,
           arrayEqs = ae,algorithms = algs, eventInfo = BackendDAE.EVENT_INFO(whenClauseLst=whenClauseLst)))
       equation
         varlst1 = varList(vars1);
@@ -443,7 +443,7 @@ algorithm
       list<DAE.ComponentRef> vars,varsws,states,statesws;
       BackendDAE.AliasVariables av;
 
-    case (dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars=variables,initialEqs=initialEqs,orderedEqs=orderedEqs),knownVars=knvars,externalObjects=exObj,aliasVars=av,removedEqs=removedEqs,
+    case (dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars=variables,initialEqs=initialEqs,orderedEqs=orderedEqs)::{},knownVars=knvars,externalObjects=exObj,aliasVars=av,removedEqs=removedEqs,
            arrayEqs=arrayEqs,algorithms=algs,eventInfo=eventInfo,extObjClasses=extObjClasses),funcs)
       equation
         /* count the unfixed variables */
@@ -506,7 +506,7 @@ algorithm
         inDAE;
 
     // unfixed greater than equations
-    case (inUnfixed,inInitialEqns,inDAE as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars=vars,initialEqs=initialEqs,orderedEqs=orderedEqs),knownVars=knvars,externalObjects=exObj,aliasVars=alisvars,removedEqs=removedEqs,
+    case (inUnfixed,inInitialEqns,inDAE as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars=vars,initialEqs=initialEqs,orderedEqs=orderedEqs)::{},knownVars=knvars,externalObjects=exObj,aliasVars=alisvars,removedEqs=removedEqs,
            arrayEqs=arrayEqs,algorithms=algs,eventInfo=eventInfo,extObjClasses=extObjClasses),funcs,inVars,inVarsWS,inStates,inStatesWS)
       equation
         true = RTOpts.debugFlag("dumpInit");
@@ -516,18 +516,18 @@ algorithm
         true = intGt(inUnfixed,inInitialEqns);
         // change fixed to true until equal equations
         (vars1,knvars1) = fixInitalVars(inUnfixed,inInitialEqns,vars,knvars,inVars,inVarsWS,inStates,inStatesWS);
-        dae1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,orderedEqs,initialEqs),knvars1,exObj,alisvars,removedEqs,arrayEqs,algs,eventInfo,extObjClasses);
+        dae1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,orderedEqs,initialEqs)::{},knvars1,exObj,alisvars,removedEqs,arrayEqs,algs,eventInfo,extObjClasses);
       then 
         dae1;
 
     // unfixed greater than equations
-    case (inUnfixed,inInitialEqns,inDAE as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars=vars,initialEqs=initialEqs,orderedEqs=orderedEqs),knownVars=knvars,externalObjects=exObj,aliasVars=alisvars,removedEqs=removedEqs,
+    case (inUnfixed,inInitialEqns,inDAE as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars=vars,initialEqs=initialEqs,orderedEqs=orderedEqs)::{},knownVars=knvars,externalObjects=exObj,aliasVars=alisvars,removedEqs=removedEqs,
            arrayEqs=arrayEqs,algorithms=algs,eventInfo=eventInfo,extObjClasses=extObjClasses),funcs,inVars,inVarsWS,inStates,inStatesWS)
       equation
         true = intGt(inUnfixed,inInitialEqns);
         // change fixed to true until equal equations
         (vars1,knvars1) = fixInitalVars(inUnfixed,inInitialEqns,vars,knvars,inVars,inVarsWS,inStates,inStatesWS);
-        dae1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,orderedEqs,initialEqs),knvars1,exObj,alisvars,removedEqs,arrayEqs,algs,eventInfo,extObjClasses);
+        dae1 = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,orderedEqs,initialEqs)::{},knvars1,exObj,alisvars,removedEqs,arrayEqs,algs,eventInfo,extObjClasses);
       then 
         dae1;
 
@@ -878,7 +878,7 @@ algorithm
       BackendDAE.EquationArray eqns,seqns,ieqns;
       BackendDAE.BackendDAE trans_dae;
       BackendDAE.ExternalObjectClasses extObjCls;
-    case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,ieqns),knvars,extVars,av,seqns,ae,al,BackendDAE.EVENT_INFO(whenClauseLst = wc,zeroCrossingLst = zc),extObjCls),_)
+    case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,ieqns)::{},knvars,extVars,av,seqns,ae,al,BackendDAE.EVENT_INFO(whenClauseLst = wc,zeroCrossingLst = zc),extObjCls),_)
       equation
         varlst = varList(vars);
         knvarlst = varList(knvars);
@@ -890,7 +890,7 @@ algorithm
         vars = BackendVariable.addVars(varlst, vars);
         knvars = BackendVariable.addVars(knvarlst, knvars);
         extVars = BackendVariable.addVars(extvarlst, extVars);
-        trans_dae = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,ieqns),knvars,extVars,av,seqns,ae,al,
+        trans_dae = BackendDAE.DAE(BackendDAE.EQSYSTEM(vars,eqns,ieqns)::{},knvars,extVars,av,seqns,ae,al,
           BackendDAE.EVENT_INFO(wc,zc),extObjCls);
       then
         trans_dae;
@@ -933,7 +933,7 @@ algorithm
       list<BackendDAE.WhenClause> wc;
       list<BackendDAE.ZeroCrossing> zc;
 
-    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars),knownVars = knvars, externalObjects = extvars,
+    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars)::{},knownVars = knvars, externalObjects = extvars,
                  eventInfo = BackendDAE.EVENT_INFO(whenClauseLst = wc,
                                         zeroCrossingLst = zc)))
       equation
@@ -1240,7 +1240,7 @@ algorithm
       list<DAE.ComponentRef> cr_lst;
       BackendDAE.BinTree bt;
       BackendDAE.Variables v;
-    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = v)))
+    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = v)::{}))
       equation
         cr_lst = BackendVariable.traverseBackendDAEVars(v,traversingisStateVarCrefFinder,{});
         bt = treeAddList(BackendDAE.emptyBintree,cr_lst);
@@ -2328,7 +2328,7 @@ public function systemSize
 algorithm
   n := match(dae)
     local BackendDAE.EquationArray eqns;
-    case(BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedEqs = eqns)))
+    case(BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedEqs = eqns)::{}))
       equation
         n = equationSize(eqns);
       then n;
@@ -2619,7 +2619,7 @@ algorithm
       array<BackendDAE.MultiDimEquation> ae;
       array<DAE.Algorithm> alg;
 
-    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = v))),arr,m,mt,a1,a2)
+    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = v)::{})),arr,m,mt,a1,a2)
       equation
         statevar_lst = BackendVariable.getAllStateVarFromVariables(v);
         ((dae,arr_1,m,mt,a1,a2)) = Util.listFold(statevar_lst, markStateEquation, (dae,arr,m,mt,a1,a2));
@@ -2657,7 +2657,7 @@ algorithm
       String s,str;
       BackendDAE.Value v_indx,v_indx_1;
 
-    case (BackendDAE.VAR(varName = cr),((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars))),arr,m,mt,a1,a2))
+    case (BackendDAE.VAR(varName = cr),((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars)::{})),arr,m,mt,a1,a2))
       equation
         (_,v_indxs) = BackendVariable.getVar(cr, vars);
         v_indxs_1 = Util.listMap1(v_indxs, intSub, 1);
@@ -2666,7 +2666,7 @@ algorithm
       then
         ((dae,arr_1,m,mt,a1,a2));
 
-    case (BackendDAE.VAR(varName = cr),((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars))),arr,m,mt,a1,a2))
+    case (BackendDAE.VAR(varName = cr),((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars)::{})),arr,m,mt,a1,a2))
       equation
         failure((_,_) = BackendVariable.getVar(cr, vars));
         print("- BackendDAEUtil.markStateEquation var ");
@@ -2676,7 +2676,7 @@ algorithm
       then
         fail();
 
-    case (BackendDAE.VAR(varName = cr),((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars))),arr,m,mt,a1,a2))
+    case (BackendDAE.VAR(varName = cr),((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars)::{})),arr,m,mt,a1,a2))
       equation
         (_,{v_indx}) = BackendVariable.getVar(cr, vars);
         v_indx_1 = v_indx - 1;
@@ -3875,7 +3875,7 @@ algorithm
       Integer numberOfEqs,numberofVars;
       list<BackendDAE.IncidenceMatrixElement> lstT;
 
-    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars,orderedEqs = eqns), eventInfo = BackendDAE.EVENT_INFO(whenClauseLst = wc)), inIndexType)
+    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars,orderedEqs = eqns)::{}, eventInfo = BackendDAE.EVENT_INFO(whenClauseLst = wc)), inIndexType)
       equation
         // get the size
         numberOfEqs = getNumberOfEquationArray(eqns);
@@ -4447,7 +4447,7 @@ algorithm
 
     case (dae,m,mt,{}) then (m,mt);
 
-    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars,orderedEqs = daeeqns),knownVars = knvars,removedEqs = daeseqns,eventInfo = BackendDAE.EVENT_INFO(whenClauseLst = wc))),m,mt,(e :: eqns))
+    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars,orderedEqs = daeeqns)::{},knownVars = knvars,removedEqs = daeseqns,eventInfo = BackendDAE.EVENT_INFO(whenClauseLst = wc))),m,mt,(e :: eqns))
       equation
         abse = intAbs(e);
         e_1 = abse - 1;
@@ -4928,7 +4928,7 @@ algorithm
         true = rhsConstant(daelow);
       then
         BackendDAE.JAC_CONSTANT();
-    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars=vars)),SOME(jac))
+    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars=vars)::{}),SOME(jac))
       equation
         true = jacobianNonlinear(vars, jac);
       then
@@ -4953,12 +4953,12 @@ algorithm
       Boolean res;
       BackendDAE.BackendDAE dae;
       BackendDAE.EquationArray eqns;
-    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedEqs = eqns))))
+    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedEqs = eqns)::{})))
       equation
         0 = equationSize(eqns);
       then
         true;
-    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedEqs = eqns))))
+    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedEqs = eqns)::{})))
       equation
         ((_,res)) = BackendEquation.traverseBackendDAEEqnsWithStop(eqns,rhsConstant2,(dae,true));
       then
@@ -4986,7 +4986,7 @@ algorithm
       array<BackendDAE.MultiDimEquation> arreqn;
 
     // check rhs for for EQUATION nodes.
-    case ((eqn as BackendDAE.EQUATION(exp = e1,scalar = e2),(dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars)),b)))
+    case ((eqn as BackendDAE.EQUATION(exp = e1,scalar = e2),(dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars)::{}),b)))
       equation
         tp = Expression.typeof(e1);
         new_exp = DAE.BINARY(e1,DAE.SUB(tp),e2);
@@ -4995,7 +4995,7 @@ algorithm
       then
         ((eqn,res,(dae,b and res)));
     // check rhs for for ARRAY_EQUATION nodes. check rhs for for RESIDUAL_EQUATION nodes.
-    case ((eqn as BackendDAE.ARRAY_EQUATION(index = indx,crefOrDerCref = expl),(dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars),arrayEqs = arreqn),b)))
+    case ((eqn as BackendDAE.ARRAY_EQUATION(index = indx,crefOrDerCref = expl),(dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars)::{},arrayEqs = arreqn),b)))
       equation
         indx_1 = indx - 1;
         BackendDAE.MULTIDIM_EQUATION(ds,e1,e2,_) = arreqn[indx + 1];
@@ -5006,7 +5006,7 @@ algorithm
       then
         ((eqn,res,(dae,b and res)));
 
-    case ((eqn as BackendDAE.RESIDUAL_EQUATION(exp = e),(dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars)),b))) /* check rhs for for RESIDUAL_EQUATION nodes. */
+    case ((eqn as BackendDAE.RESIDUAL_EQUATION(exp = e),(dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars)::{}),b))) /* check rhs for for RESIDUAL_EQUATION nodes. */
       equation
         rhs_exp = getEqnsysRhsExp(e, vars);
         res = Expression.isConst(rhs_exp);
@@ -5364,7 +5364,7 @@ algorithm
       array<BackendDAE.MultiDimEquation> ae;
       array<DAE.Algorithm> algs;
       Type_a ext_arg_1,ext_arg_2,ext_arg_3,ext_arg_4,ext_arg_5,ext_arg_6,ext_arg_7;
-    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars1,orderedEqs = eqns,initialEqs = ieqns),
+    case (BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars1,orderedEqs = eqns,initialEqs = ieqns)::{},
       knownVars = vars2,removedEqs = reqns,arrayEqs = ae,algorithms = algs),func,inTypeA)
       equation
         ext_arg_1 = traverseBackendDAEExpsVars(vars1,func,inTypeA);

diff --git a/Compiler/BackEnd/BackendDump.mo b/Compiler/BackEnd/BackendDump.mo
@@ -203,7 +203,7 @@ algorithm
       BackendDAE.Value eqno_1,eqno;
       BackendDAE.Equation eq;
       BackendDAE.EquationArray eqns;
-    case (eqno,BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedEqs = eqns)))
+    case (eqno,BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedEqs = eqns)::{}))
       equation
         eqno_1 = eqno - 1;
         eq = BackendDAEUtil.equationNth(eqns, eqno_1);
@@ -629,7 +629,7 @@ algorithm
       list<BackendDAE.ZeroCrossing> zc;
       list<BackendDAE.WhenClause> wc;
       BackendDAE.ExternalObjectClasses extObjCls;
-    case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,eqns,ieqns),vars2,vars3,av,reqns,ae,algs,BackendDAE.EVENT_INFO(zeroCrossingLst = zc,whenClauseLst=wc),extObjCls))
+    case (BackendDAE.DAE(BackendDAE.EQSYSTEM(vars1,eqns,ieqns)::{},vars2,vars3,av,reqns,ae,algs,BackendDAE.EVENT_INFO(zeroCrossingLst = zc,whenClauseLst=wc),extObjCls))
       equation
         print("Variables (");
         vars = BackendDAEUtil.varList(vars1);
@@ -1420,7 +1420,7 @@ algorithm
       BackendDAE.EquationArray eqns;
       list<BackendDAE.Value> es;
     case (_,{}) then "";
-    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedEqs = eqns))),(e :: es))
+    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedEqs = eqns)::{})),(e :: es))
       equation
         s1 = dumpMarkedEqns(dae, es);
         e_1 = e - 1;
@@ -1448,7 +1448,7 @@ algorithm
       BackendDAE.Variables vars;
       list<BackendDAE.Value> vs;
     case (_,{}) then "";
-    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars))),(v :: vs))
+    case ((dae as BackendDAE.DAE(eqs=BackendDAE.EQSYSTEM(orderedVars = vars)::{})),(v :: vs))
       equation
         s1 = dumpMarkedVars(dae, vs);
         BackendDAE.VAR(varName = cr) = BackendVariable.getVarAt(vars, v);