some small optimizations

Compiler/BackEnd/BackendDAECreate.mo

@@ -595,20 +595,20 @@ algorithm
       DAE.CallAttributes attr;
 
     // delay [already in ht]
-    case (DAE.CALL(Absyn.IDENT("delay"), es, attr), (ht, iDelay, iSample, timeEvents)) equation
+    case (DAE.CALL(Absyn.IDENT("delay"), es, attr), (ht, _, _, _)) equation
       i = BaseHashTable.get(inExp, ht);
-    then (DAE.CALL(Absyn.IDENT("delay"), DAE.ICONST(i)::es, attr), (ht, iDelay, iSample, timeEvents));
+    then (DAE.CALL(Absyn.IDENT("delay"), DAE.ICONST(i)::es, attr), inTuple);
 
     // delay [not yet in ht]
     case (DAE.CALL(Absyn.IDENT("delay"), es, attr), (ht, iDelay, iSample, timeEvents)) equation
       ht = BaseHashTable.add((inExp, iDelay+1), ht);
     then (DAE.CALL(Absyn.IDENT("delay"), DAE.ICONST(iDelay)::es, attr), (ht, iDelay+1, iSample, timeEvents));
 
     // sample [already in ht]
-    case (DAE.CALL(Absyn.IDENT("sample"), es as {_, interval}, attr), (ht, iDelay, iSample, timeEvents))
+    case (DAE.CALL(Absyn.IDENT("sample"), es as {_, interval}, attr), (ht, _, _, _))
     guard (not Types.isClockOrSubTypeClock(Expression.typeof(interval))) equation
       i = BaseHashTable.get(inExp, ht);
-    then (DAE.CALL(Absyn.IDENT("sample"), DAE.ICONST(i)::es, attr), (ht, iDelay, iSample, timeEvents));
+    then (DAE.CALL(Absyn.IDENT("sample"), DAE.ICONST(i)::es, attr), inTuple);
 
     // sample [not yet in ht]
     case (DAE.CALL(Absyn.IDENT("sample"), es as {start, interval}, attr), (ht, iDelay, iSample, timeEvents))

Compiler/BackEnd/BackendDAEUtil.mo

@@ -3789,7 +3789,7 @@ public function getAdjacencyMatrixEnhancedScalar
   output array<list<Integer>> outMapEqnIncRow;
   output array<Integer> outMapIncRowEqn;
 protected
-  list<list<tuple<Integer,list<Integer>>>> varsSolvedInWhenEqnsTupleList;
+  list<tuple<Integer,list<Integer>>> varsSolvedInWhenEqnsTupleList;
 algorithm
   (outIncidenceMatrix,outIncidenceMatrixT,outMapEqnIncRow,outMapIncRowEqn) :=
   matchcontinue (syst, shared)
@@ -3823,7 +3823,7 @@ algorithm
         fail();
   end matchcontinue;
 
-  makeWhenEqnVarsUnsolvable(outIncidenceMatrix,outIncidenceMatrixT,List.flatten(varsSolvedInWhenEqnsTupleList));
+  makeWhenEqnVarsUnsolvable(outIncidenceMatrix,outIncidenceMatrixT,varsSolvedInWhenEqnsTupleList);
 end getAdjacencyMatrixEnhancedScalar;
 
 
@@ -3895,7 +3895,7 @@ protected function adjacencyMatrixDispatchEnhancedScalar
   input Boolean trytosolve;
   output array<list<Integer>> omapEqnIncRow;
   output array<Integer> omapIncRowEqn;
-  output list<list<tuple<Integer,list<Integer>>>> varsSolvedInWhenEqnsTupleListOut = {};
+  output list<tuple<Integer,list<Integer>>> varsSolvedInWhenEqnsTupleListOut = {};
 protected
   list<BackendDAE.AdjacencyMatrixElementEnhanced> inIncidenceArray = {};
   list<list<Integer>> mapEqnIncRow = {};
@@ -3917,7 +3917,7 @@ algorithm
     // put it in the arrays
     inIncidenceArray := List.consN(size,row,inIncidenceArray);
     incidenceArrayT := fillincAdjacencyMatrixTEnhanced(row,rowindxs,incidenceArrayT);
-    varsSolvedInWhenEqnsTupleListOut := varsSolvedInWhenEqnsTuple :: varsSolvedInWhenEqnsTupleListOut;
+    varsSolvedInWhenEqnsTupleListOut := listAppend(varsSolvedInWhenEqnsTuple, varsSolvedInWhenEqnsTupleListOut);
     mapEqnIncRow := rowindxs::mapEqnIncRow;
   end for;
   outIncidenceArray := List.listArrayReverse(inIncidenceArray);
@@ -4041,9 +4041,9 @@ algorithm
       equation
         row = inIncidenceArrayT[v];
         newrow = List.map2(eqnsindxs,Util.make3Tuple,solva,cons);
-        newrow = listAppend(newrow,row);
+        row = listAppend(newrow,row);
         // put it in the array
-        mT = arrayUpdate(inIncidenceArrayT, v, newrow);
+        mT = arrayUpdate(inIncidenceArrayT, v, row);
       then
         fillincAdjacencyMatrixTEnhanced(rest, eqnsindxs, mT);
 
@@ -4054,8 +4054,8 @@ algorithm
         eqnsindxs1 = List.map(eqnsindxs,intNeg);
         newrow = List.map2(eqnsindxs1,Util.make3Tuple,solva,cons);
         // put it in the array
-        newrow = listAppend(newrow,row);
-        mT = arrayUpdate(inIncidenceArrayT, vabs, newrow);
+        row = listAppend(newrow,row);
+        mT = arrayUpdate(inIncidenceArrayT, vabs, row);
       then
         fillincAdjacencyMatrixTEnhanced(rest, eqnsindxs, mT);
 
@@ -4339,7 +4339,7 @@ protected function adjacencyRowAlgorithmInputs1
   input BackendDAE.AdjacencyMatrixElementEnhanced iRow;
   output BackendDAE.AdjacencyMatrixElementEnhanced outRow;
 algorithm
-  outRow := matchcontinue(vindx,mark,rowmark,iRow)
+  outRow := match(vindx,mark,rowmark,iRow)
     local
       Integer i;
       list<Integer> rest;
@@ -4353,12 +4353,9 @@ algorithm
       then
         adjacencyRowAlgorithmInputs1(rest,mark,rowmark,(i,BackendDAE.SOLVABILITY_UNSOLVABLE(),{})::iRow);
     case (i::rest,_,_,_)
-      guard
-        // already handled
-        intEq(intAbs(rowmark[i]),mark)
       then
         adjacencyRowAlgorithmInputs1(rest,mark,rowmark,iRow);
-  end matchcontinue;
+  end match;
 end adjacencyRowAlgorithmInputs1;
 
 protected function adjacencyRowWhenEnhanced

Compiler/BackEnd/EvaluateFunctions.mo

@@ -2671,6 +2671,7 @@ algorithm
       DAE.FunctionTree funcs;
       list<BackendDAE.Equation> addEqs;
       list<DAE.Statement> stmts,stmtsIn;
+      tuple<DAE.Exp, DAE.FunctionTree,Integer,list<DAE.Statement>> tpl;
   case (DAE.CALL(),(lhs,funcs,idx,stmtsIn))
     equation
       ((rhs,lhs,addEqs,funcs,idx,_,_)) = evaluateConstantFunction(inExp,lhs,funcs,idx,{});
@@ -2680,11 +2681,10 @@ algorithm
 
   case (DAE.UNBOX(exp=rhs),_)
     equation
-      (rhs,_,(lhs,funcs,idx,stmts)) = evaluateConstantFunctionWrapper(rhs,inTpl);
-    then (rhs,true,(lhs,funcs,idx,stmts));
+      (rhs,_,tpl) = evaluateConstantFunctionWrapper(rhs,inTpl);
+    then (rhs,true,tpl);
 
-  case (rhs,(_,_,_,_))
-    then (rhs,false,inTpl);
+  else (inExp,false,inTpl);
   end matchcontinue;
 end evaluateConstantFunctionWrapper;