- Expression: check type before add,sub,mul,div expression

- ExpressionSolve.mo: cases for cr = exp, exp=cr, -cr=exp,exp=-cr,!cr=exp,exp=!cr
- ExpressionSimplify: pre(a+b) -> pre(a)+pre(b)
- move some test to working group

git-svn-id: https://openmodelica.org/svn/OpenModelica/trunk@13597 f25d12d1-65f4-0310-ae8a-bbce733d8d8e

Author: Jens Frenkel

Compiler/BackEnd/ExpressionSolve.mo

@@ -264,7 +264,7 @@ algorithm
   (outExp,outAsserts) := matchcontinue (inExp1,inExp2,inExp3,linearExps)
     local
       DAE.Exp lhs,lhsder,lhsder_1,lhszero,lhszero_1,rhs,rhs_1,e1,e2,crexp,e,a,z;
-      DAE.ComponentRef cr;
+      DAE.ComponentRef cr,cr1;
       DAE.Exp invCr;
       list<DAE.Exp> factors;
       Boolean linExp;
@@ -337,6 +337,67 @@ algorithm
       then
         (rhs_1,DAE.STMT_ASSERT(DAE.RELATION(a,DAE.NEQUAL(tp),z,-1,NONE()),DAE.SCONST(estr),DAE.ASSERTIONLEVEL_ERROR,DAE.emptyElementSource)::asserts);
 
+    // cr = exp    
+    case (DAE.CREF(componentRef = cr1),e2,(crexp as DAE.CREF(componentRef = cr)),linExp)
+      equation
+        true = ComponentReference.crefEqual(cr1,cr);
+        // cr not in e2
+        false = Expression.expHasCref(e2,cr);
+      then
+        (e2,{});
+        
+    // exp = cr    
+    case (e1,DAE.CREF(componentRef = cr1),(crexp as DAE.CREF(componentRef = cr)),linExp)
+      equation
+        true = ComponentReference.crefEqual(cr1,cr);
+        // cr not in e2
+        false = Expression.expHasCref(e1,cr);
+      then
+        (e1,{});
+       
+    // -cr = exp    
+    case (DAE.UNARY(operator = DAE.UMINUS(ty=_), exp = DAE.CREF(componentRef = cr1)),e2,(crexp as DAE.CREF(componentRef = cr)),linExp)
+      equation
+        true = ComponentReference.crefEqual(cr1,cr);
+        // cr not in e2
+        false = Expression.expHasCref(e2,cr);
+      then
+        (Expression.negate(e2),{});
+    case (DAE.UNARY(operator = DAE.UMINUS_ARR(ty=_), exp = DAE.CREF(componentRef = cr1)),e2,(crexp as DAE.CREF(componentRef = cr)),linExp)
+      equation
+        true = ComponentReference.crefEqual(cr1,cr);
+        // cr not in e2
+        false = Expression.expHasCref(e2,cr);
+      then
+        (Expression.negate(e2),{});        
+
+    // exp = -cr    
+    case (e1,DAE.LUNARY(operator = DAE.UMINUS_ARR(ty=_), exp = DAE.CREF(componentRef = cr1)),(crexp as DAE.CREF(componentRef = cr)),linExp)
+      equation
+        true = ComponentReference.crefEqual(cr1,cr);
+        // cr not in e2
+        false = Expression.expHasCref(e1,cr);
+      then
+        (Expression.negate(e1),{});     
+        
+    // !cr = exp    
+    case (DAE.LUNARY(operator = DAE.NOT(ty=_), exp = DAE.CREF(componentRef = cr1)),e2,(crexp as DAE.CREF(componentRef = cr)),linExp)
+      equation
+        true = ComponentReference.crefEqual(cr1,cr);
+        // cr not in e2
+        false = Expression.expHasCref(e2,cr);
+      then
+        (Expression.negate(e2),{});
+        
+    // exp = !cr    
+    case (e1,DAE.LUNARY(operator = DAE.NOT(ty=_), exp = DAE.CREF(componentRef = cr1)),(crexp as DAE.CREF(componentRef = cr)),linExp)
+      equation
+        true = ComponentReference.crefEqual(cr1,cr);
+        // cr not in e2
+        false = Expression.expHasCref(e1,cr);
+      then
+        (Expression.negate(e1),{});   
+
     case (e1,e2,(crexp as DAE.CREF(componentRef = cr)), linExp)
       equation
         lhs = Expression.makeDiff(e1,e2);

Compiler/FrontEnd/Expression.mo

@@ -2698,6 +2698,7 @@ algorithm
     case (_,_)
       equation
         tp = typeof(e1);
+        true = Types.isIntegerOrRealOrSubTypeOfEither(tp);
         b = DAEUtil.expTypeArray(tp) "  array_elt_type(tp) => tp\'" ;
         op = Util.if_(b,DAE.ADD_ARR(tp),DAE.ADD(tp));
       then
@@ -2762,6 +2763,7 @@ algorithm
     case (_,_)
       equation
         tp = typeof(e1);
+        true = Types.isIntegerOrRealOrSubTypeOfEither(tp);
         b = DAEUtil.expTypeArray(tp);
         op = Util.if_(b,DAE.SUB_ARR(tp),DAE.SUB(tp));
       then
@@ -2963,8 +2965,10 @@ algorithm
     case (_,_)
       equation
         tp = typeof(e1);
+        true = Types.isIntegerOrRealOrSubTypeOfEither(tp);
         b1 = DAEUtil.expTypeArray(tp);
         tp = typeof(e2);
+        true = Types.isIntegerOrRealOrSubTypeOfEither(tp);
         b2 = DAEUtil.expTypeArray(tp);
         /* swap e1 and e2 if we have scalar mul array */
         (e1_1,e2_1) = Util.swap((not b1) and b2, e1, e2);
@@ -3136,6 +3140,7 @@ protected
   Operator op;
 algorithm
   tp := typeof(e1);
+  true := Types.isIntegerOrRealOrSubTypeOfEither(tp);
   b := DAEUtil.expTypeArray(tp);
   op := Util.if_(b,DAE.DIV_ARR(tp),DAE.DIV(tp));
   outExp := DAE.BINARY(e1,op,e2);

Compiler/FrontEnd/ExpressionSimplify.mo

@@ -229,12 +229,23 @@ algorithm
         // TODO: Do this better?
       then 
         ((e3,(b,options)));
+
+    case ((e as DAE.CALL(path=Absyn.IDENT("pre"), expLst={DAE.CREF(componentRef=_)}), (b, options)))
+      then
+        ((e,(b,options)));
 
     case ((DAE.CALL(path=Absyn.IDENT("pre"), expLst={e as DAE.ASUB(exp = exp)}), (b, options)))
       equation
         true = Expression.isConst(exp);
       then
         ((e,(true,options)));
+
+    // move pre inside
+    case ((DAE.CALL(path=Absyn.IDENT("pre"), expLst={e}), (b, options)))
+      equation
+        ((e,_)) = Expression.traverseExp(e,preCref,false);
+      then
+        ((e,(true,options)));
 
     // normal call 
     case ((e as DAE.CALL(expLst=expl),(_,options)))
@@ -385,6 +396,20 @@ algorithm
   end matchcontinue;
 end simplifyWork;
 
+protected function preCref
+  input tuple<DAE.Exp,Boolean> iExp;
+  output tuple<DAE.Exp,Boolean> oExp;
+algorithm
+  oExp := match(iExp)
+    local
+      DAE.Exp e;
+      Boolean b;
+      DAE.Type ty;
+    case ((e as DAE.CREF(ty=ty),_)) then ((DAE.CALL(Absyn.IDENT("pre"),{e},DAE.CALL_ATTR(ty,false,true,DAE.NO_INLINE(),DAE.NO_TAIL())),true));
+    else then iExp;
+  end match;
+end preCref;
+
 public function simplify1
 "function: simplify1
   This function does some very basic simplification