- DAELow.mo

  move DelayExpression stuff to SimCode.mo and delete duplicatet functions

git-svn-id: https://openmodelica.org/svn/OpenModelica/branches/sjoelund-functiontree@6662 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Author: Jens Frenkel

Compiler/BackendDAECreate.mo

@@ -3353,5 +3353,4 @@ algorithm
   end matchcontinue;
 end whenEquationsIndices2;
 
-
 end BackendDAECreate;

Compiler/DAELow.mo

@@ -6037,82 +6037,6 @@ algorithm
   end matchcontinue;
 end generateDaeType;
 
-protected function transformDelayExpression
-"Insert a unique index into the arguments of a delay() expression.
-Repeat delay as maxDelay if not present."
-  input tuple<DAE.Exp, Integer> inTuple;
-  output tuple<DAE.Exp, Integer> outTuple;
-algorithm
-  outTuple := matchcontinue(inTuple)
-    local
-      DAE.Exp e, e1, e2, e3;
-      Integer i;
-      list<DAE.Exp> l;
-      Boolean t, b;
-      DAE.ExpType ty;
-      DAE.InlineType it;
-    case ((DAE.CALL(Absyn.IDENT("delay"), {e1, e2}, t, b, ty, it), i))
-      then ((DAE.CALL(Absyn.IDENT("delay"), {DAE.ICONST(i), e1, e2, e2}, t, b, ty, it), i + 1));
-    case ((DAE.CALL(Absyn.IDENT("delay"), {e1, e2, e3}, t, b, ty, it), i))
-      then ((DAE.CALL(Absyn.IDENT("delay"), {DAE.ICONST(i), e1, e2, e3}, t, b, ty, it), i + 1));
-    case ((e, i)) then ((e, i));
-  end matchcontinue;
-end transformDelayExpression;
-
-protected function transformDelayExpressions
-"Helper for processDelayExpressions()"
-  input DAE.Exp inExp;
-  input Integer inInteger;
-  output DAE.Exp outExp;
-  output Integer outInteger;
-algorithm
-  ((outExp, outInteger)) := Expression.traverseExp(inExp, transformDelayExpression, inInteger);
-end transformDelayExpressions;
-
-public function processDelayExpressions
-"Assign each call to delay() with a unique id argument"
-  input DAE.DAElist inDAE;
-  input DAE.FunctionTree functionTree;
-  output DAE.DAElist outDAE;
-  output DAE.FunctionTree outTree;
-algorithm
-  (outDAE,outTree) := matchcontinue(inDAE,functionTree)
-    local
-      DAE.DAElist dae, dae2;
-    case (dae,functionTree)
-      equation
-        (dae,functionTree,_) = DAEUtil.traverseDAE(dae, functionTree, transformDelayExpressions, 0);
-      then
-        (dae,functionTree);
-  end matchcontinue;
-end processDelayExpressions;
-
-protected function collectDelayExpressions
-"Put expression into a list if it is a call to delay().
-Useable as a function parameter for Expression.traverseExpression."
-  input tuple<DAE.Exp, list<DAE.Exp>> inTuple;
-  output tuple<DAE.Exp, list<DAE.Exp>> outTuple;
-algorithm
-  outTuple := matchcontinue(inTuple)
-    local
-      DAE.Exp e;
-      list<DAE.Exp> l;
-    case ((e as DAE.CALL(path = Absyn.IDENT("delay")), l))
-      then ((e, e :: l));
-    case ((e, l)) then ((e, l));
-  end matchcontinue;
-end collectDelayExpressions;
-
-public function findDelaySubExpressions
-"Return all subexpressions of inExp that are calls to delay()"
-  input DAE.Exp inExp;
-  input list<Integer> inDummy "this is a dummy for traverseDAELowExps";
-  output list<DAE.Exp> outExps;
-algorithm
-  ((_, outExps)) := Expression.traverseExp(inExp, collectDelayExpressions, {});
-end findDelaySubExpressions;
-
-
 public function generateCrefsExpFromType "
 Author: Frenkel TUD 2010-05"
   input DAE.ExpVar inVar;

Compiler/SimCode.mo

@@ -1831,6 +1831,31 @@ algorithm
   end matchcontinue;
 end createLinearModelMatrixes;
 
+protected function collectDelayExpressions
+"Put expression into a list if it is a call to delay().
+Useable as a function parameter for Expression.traverseExpression."
+  input tuple<DAE.Exp, list<DAE.Exp>> inTuple;
+  output tuple<DAE.Exp, list<DAE.Exp>> outTuple;
+algorithm
+  outTuple := matchcontinue(inTuple)
+    local
+      DAE.Exp e;
+      list<DAE.Exp> l;
+    case ((e as DAE.CALL(path = Absyn.IDENT("delay")), l))
+      then ((e, e :: l));
+    case ((e, l)) then ((e, l));
+  end matchcontinue;
+end collectDelayExpressions;
+
+protected function findDelaySubExpressions
+"Return all subexpressions of inExp that are calls to delay()"
+  input DAE.Exp inExp;
+  input list<Integer> inDummy "this is a dummy for traverseDAELowExps";
+  output list<DAE.Exp> outExps;
+algorithm
+  ((_, outExps)) := Expression.traverseExp(inExp, collectDelayExpressions, {});
+end findDelaySubExpressions;
+
 protected function extractDelayedExpressions
   input BackendDAE.DAELow dlow;
   output list<tuple<Integer, DAE.Exp>> delayedExps;
@@ -1841,7 +1866,7 @@ algorithm
       list<DAE.Exp> exps;
     case (dlow)
       equation
-        exps = DAELow.traverseDAELowExps(dlow,true,DAELow.findDelaySubExpressions,{});
+        exps = DAELow.traverseDAELowExps(dlow,true,findDelaySubExpressions,{});
         delayedExps = Util.listMap(exps, extractIdAndExpFromDelayExp);
         maxDelayedExpIndex = Util.listFold(Util.listMap(delayedExps, Util.tuple21), intMax, -1);
       then