Skip to content

Commit

Permalink
BackendDAE.ASSIGN can hold tuples on lhs
Browse files Browse the repository at this point in the history
  • Loading branch information
@vwaurich
vwaurich committed Oct 24, 2016
1 parent dd59e54 commit 1692f27
Show file tree
Hide file tree
Showing 27 changed files with 219 additions and 100 deletions.
2 changes: 1 addition & 1 deletion Compiler/BackEnd/BackendDAE.mo
View file
Expand Up @@ -389,7 +389,7 @@ end WhenEquation;
public
uniontype WhenOperator
record ASSIGN " left_cr = right_exp"
.DAE.ComponentRef left "left hand side of equation";
.DAE.Exp left "left hand side of equation";
.DAE.Exp right "right hand side of equation";
.DAE.ElementSource source "origin of equation";
end ASSIGN;
Expand Down
60 changes: 42 additions & 18 deletions Compiler/BackEnd/BackendDAECreate.mo
View file
Expand Up @@ -1875,12 +1875,14 @@ algorithm
Integer size;
list<BackendDAE.Equation> eqnl;
list<BackendDAE.Equation> reqnl;
DAE.Exp cre, e, cond, level;
DAE.Exp cre, e, lhs, cond, level;
DAE.ComponentRef cr, cr2;
list<DAE.Element> xs, eqns;
DAE.Element el;
DAE.ElementSource source;
DAE.Dimensions ds;
DAE.Statement stmt;
DAE.Type ty;
list<DAE.Exp> expl;
list<list<DAE.Element>> eqnslst;
Absyn.Path functionName;
Expand All @@ -1895,7 +1897,7 @@ algorithm
case DAE.EQUEQUATION(cr1 = cr, cr2 = cr2, source = source)::xs
equation
e = Expression.crefExp(cr2);
whenOp = BackendDAE.ASSIGN(cr, e, source);
whenOp = BackendDAE.ASSIGN(Expression.crefExp(cr), e, source);
whenEq = BackendDAE.WHEN_STMTS(inCond, {whenOp}, NONE());
eq = BackendDAE.WHEN_EQUATION(1, whenEq, source, BackendDAE.EQ_ATTR_DEFAULT_DYNAMIC);
(eqnl, reqnl) = lowerWhenEqn2(xs, inCond, functionTree, eq::iEquationLst, iREquationLst);
Expand All @@ -1906,13 +1908,25 @@ algorithm
equation
(e, _) = ExpressionSolve.solve(Expression.crefExp(cr), e, Expression.crefExp(cr));
(DAE.PARTIAL_EQUATION(e), source) = ExpressionSimplify.simplifyAddSymbolicOperation(DAE.PARTIAL_EQUATION(e),source);
whenOp = BackendDAE.ASSIGN(cr, e, source);
whenOp = BackendDAE.ASSIGN(Expression.crefExp(cr), e, source);
whenEq = BackendDAE.WHEN_STMTS(inCond, {whenOp}, NONE());
eq = BackendDAE.WHEN_EQUATION(1, whenEq, source, BackendDAE.EQ_ATTR_DEFAULT_DYNAMIC);
(eqnl, reqnl) = lowerWhenEqn2(xs, inCond, functionTree, eq::iEquationLst, iREquationLst);
then
(eqnl, reqnl);

// if a function call includes external functions, it is not allowed to expand the left hand side since the call will be evaluated multiple times. That's an unintended behaviour.
case DAE.EQUATION(exp = lhs as DAE.TUPLE(PR=expl), scalar = e as DAE.CALL(_), source = source)::xs
equation
//print("Do not lower equations with function calls that solve tuples "+DAEDump.dumpEquationStr(listHead(inDAEElementLst))+"\n");
ty = Expression.typeof(lhs);
size = Expression.sizeOf(ty);
eq = BackendDAE.WHEN_EQUATION(size, BackendDAE.WHEN_STMTS(inCond, {BackendDAE.ASSIGN(lhs, e, source)},NONE()), source, BackendDAE.EQ_ATTR_DEFAULT_DYNAMIC);
eqnl = eq::iEquationLst;
(eqnl, reqnl) = lowerWhenEqn2(xs, inCond, functionTree, eqnl, iREquationLst);
then
(eqnl, reqnl);

case DAE.EQUATION(exp = DAE.TUPLE(PR=expl), scalar = e, source = source)::xs
equation
eqnl = lowerWhenTupleEqn(expl, inCond, e, source, 1, iEquationLst);
Expand All @@ -1928,7 +1942,7 @@ algorithm
fail();
end try;
(DAE.PARTIAL_EQUATION(e), source) := ExpressionSimplify.simplifyAddSymbolicOperation(DAE.PARTIAL_EQUATION(e),source);
whenOp := BackendDAE.ASSIGN(cr, e, source);
whenOp := BackendDAE.ASSIGN(cre, e, source);
whenEq := BackendDAE.WHEN_STMTS(inCond, {whenOp}, NONE());
eq := BackendDAE.WHEN_EQUATION(1, whenEq, source, BackendDAE.EQ_ATTR_DEFAULT_DYNAMIC);
(eqnl, reqnl) := lowerWhenEqn2(xs, inCond, functionTree, eq::iEquationLst, iREquationLst);
Expand All @@ -1938,7 +1952,7 @@ algorithm
equation
(DAE.EQUALITY_EXPS(_,e), source) = ExpressionSimplify.simplifyAddSymbolicOperation(DAE.EQUALITY_EXPS(cre,e),source);
size = Expression.sizeOf(Expression.typeof(cre));
whenOp = BackendDAE.ASSIGN(cr, e, source);
whenOp = BackendDAE.ASSIGN(cre, e, source);
whenEq = BackendDAE.WHEN_STMTS(inCond, {whenOp}, NONE());
eq = BackendDAE.WHEN_EQUATION(size, whenEq, source, BackendDAE.EQ_ATTR_DEFAULT_DYNAMIC);
(eqnl, reqnl) = lowerWhenEqn2(xs, inCond, functionTree, eq::iEquationLst, iREquationLst);
Expand Down Expand Up @@ -1973,7 +1987,7 @@ algorithm
equation
(DAE.EQUALITY_EXPS(_,e), source) = ExpressionSimplify.simplifyAddSymbolicOperation(DAE.EQUALITY_EXPS(cre,e),source);
size = List.fold(Expression.dimensionsSizes(ds), intMul, 1);
whenOp = BackendDAE.ASSIGN(cr, e, source);
whenOp = BackendDAE.ASSIGN(cre, e, source);
whenEq = BackendDAE.WHEN_STMTS(inCond, {whenOp}, NONE());
eq = BackendDAE.WHEN_EQUATION(size, whenEq, source, BackendDAE.EQ_ATTR_DEFAULT_DYNAMIC);
(eqnl, reqnl) = lowerWhenEqn2(xs, inCond, functionTree, eq::iEquationLst, iREquationLst);
Expand Down Expand Up @@ -2066,7 +2080,7 @@ algorithm
case (DAE.CREF(componentRef = cr, ty=ty)::rest, _, _, _, _, _)
equation
size = Expression.sizeOf(ty);
whenOp = BackendDAE.ASSIGN(cr, DAE.TSUB(e, i, ty), source);
whenOp = BackendDAE.ASSIGN(Expression.crefExp(cr), DAE.TSUB(e, i, ty), source);
whenEq = BackendDAE.WHEN_STMTS(inCond, {whenOp}, NONE());
then
lowerWhenTupleEqn(rest, inCond, e, source, i+1, BackendDAE.WHEN_EQUATION(size, whenEq, source, BackendDAE.EQ_ATTR_DEFAULT_DYNAMIC) ::iEquationLst);
Expand Down Expand Up @@ -2099,7 +2113,7 @@ algorithm
equation
source = ElementSource.mergeSources(iSource, source);
size = Expression.sizeOf(Expression.typeof(e));
whenOp = BackendDAE.ASSIGN(cr, e, source);
whenOp = BackendDAE.ASSIGN(Expression.crefExp(cr), e, source);
whenEq = BackendDAE.WHEN_STMTS(inCond, {whenOp}, NONE());
then
lowerWhenIfEqns2(rest, inCond, iSource, BackendDAE.WHEN_EQUATION(size, whenEq, source, BackendDAE.EQ_ATTR_DEFAULT_DYNAMIC)::inEqns);
Expand Down Expand Up @@ -2363,14 +2377,15 @@ algorithm
for elem in whenStmtLst loop
_ := match elem
local
DAE.ComponentRef left;
case BackendDAE.ASSIGN(left=left) algorithm
DAE.ComponentRef crleft;
DAE.Exp eleft;
case BackendDAE.ASSIGN(left=eleft) algorithm
for stmt in whenStmtLst2 loop
_ := matchcontinue stmt
local
DAE.ComponentRef left2;
case BackendDAE.ASSIGN(left=left2) equation
true = ComponentReference.crefEqualNoStringCompare(left, left2);
DAE.Exp eleft2;
case BackendDAE.ASSIGN(left=eleft2) equation
true = Expression.expEqual(eleft, eleft2);
//print(" added when else case: \n" + BackendDump.whenEquationString(eq, true) + "\n");
whenEqRes = BackendEquation.setWhenElsePart(whenEq, eq);
res = BackendDAE.WHEN_EQUATION(size, whenEqRes, source, attr);
Expand All @@ -2383,13 +2398,13 @@ algorithm
end matchcontinue;
end for;
then ();
case BackendDAE.REINIT(stateVar=left) algorithm
case BackendDAE.REINIT(stateVar=crleft) algorithm
for stmt in whenStmtLst2 loop
_ := matchcontinue stmt
local
DAE.ComponentRef left2;
case BackendDAE.REINIT(stateVar=left2) equation
true = ComponentReference.crefEqualNoStringCompare(left, left2);
DAE.ComponentRef crleft2;
case BackendDAE.REINIT(stateVar=crleft2) equation
true = ComponentReference.crefEqualNoStringCompare(crleft, crleft2);
//print(" added when else case: \n" + BackendDump.whenEquationString(eq, true) + "\n");
whenEqRes = BackendEquation.setWhenElsePart(whenEq, eq);
res = BackendDAE.WHEN_EQUATION(size, whenEqRes, source, attr);
Expand Down Expand Up @@ -3113,14 +3128,23 @@ algorithm
outVariables := matchcontinue (inEquation, inGlobalKnownVars, inVariables)
local
DAE.ComponentRef cr;
list<DAE.ComponentRef> crefs;
DAE.Exp e;
list<BackendDAE.Var> vars;
list<DAE.Statement> statementLst;
list<BackendDAE.WhenOperator> whenStmts;
case (BackendDAE.WHEN_EQUATION(whenEquation = BackendDAE.WHEN_STMTS(whenStmtLst = {BackendDAE.ASSIGN(left=cr)})), _, _)
case (BackendDAE.WHEN_EQUATION(whenEquation = BackendDAE.WHEN_STMTS(whenStmtLst = {BackendDAE.ASSIGN(left=DAE.CREF(componentRef=cr))})), _, _)
equation
(vars, _) = BackendVariable.getVar(cr, inVariables);
vars = List.map1(vars, BackendVariable.setVarKind, BackendDAE.DISCRETE());
then BackendVariable.addVars(vars, inVariables);
case (BackendDAE.WHEN_EQUATION(whenEquation = BackendDAE.WHEN_STMTS(whenStmtLst = {BackendDAE.ASSIGN(left=e)})), _, _)
equation
crefs = Expression.getAllCrefs(e);
crefs = List.flatten(List.map1(crefs,ComponentReference.expandCref,true));
(vars, _) = BackendVariable.getVarLst(crefs, inVariables);
vars = List.map1(vars, BackendVariable.setVarKind, BackendDAE.DISCRETE());
then BackendVariable.addVars(vars, inVariables);
case (BackendDAE.ALGORITHM(alg=DAE.ALGORITHM_STMTS(statementLst = statementLst)), _, _)
then detectImplicitDiscreteAlgsStatemens(inVariables, inGlobalKnownVars, statementLst, false);
else inVariables;
Expand Down
8 changes: 4 additions & 4 deletions Compiler/BackEnd/BackendDAETransform.mo
View file
Expand Up @@ -761,15 +761,15 @@ algorithm
rs := match(rs)
local
DAE.ComponentRef cr;
DAE.Exp cond, msg, level, exp;
DAE.Exp lhs,cond, msg, level, exp;
DAE.ElementSource src;
list<DAE.SymbolicOperation> ops;

case BackendDAE.ASSIGN(cr, cond, src) equation
case BackendDAE.ASSIGN(lhs, cond, src) equation
(cond, (ops, outArg)) = func(cond, ({}, inArg));
(DAE.CREF(componentRef = cr), (ops, outArg)) = func(Expression.crefExp(cr), (ops,outArg));
(lhs, (ops, outArg)) = func(lhs, (ops,outArg));
src = List.foldr(ops, ElementSource.addSymbolicTransformation, src);
then BackendDAE.ASSIGN(cr, cond, src);
then BackendDAE.ASSIGN(lhs, cond, src);

case BackendDAE.REINIT(cr, cond, src) equation
(cond, (ops, outArg)) = func(cond, ({}, inArg));
Expand Down
24 changes: 19 additions & 5 deletions Compiler/BackEnd/BackendDAEUtil.mo
View file
Expand Up @@ -2519,15 +2519,15 @@ algorithm
list<BackendDAE.WhenOperator> rest;

case {} then inRow;
case (BackendDAE.ASSIGN(left = DAE.WILD(), right = e2)::rest)
case (BackendDAE.ASSIGN(left = DAE.CREF(componentRef = DAE.WILD()), right = e2)::rest)
equation
outRow = incidenceRowExp(e2, inVariables, inRow, functionTree, inIndexType);
outRow = incidenceRowWhenOps(rest, inVariables, inIndexType, functionTree, outRow);
then outRow;

case (BackendDAE.ASSIGN(left = cr, right = e2)::rest)
case (BackendDAE.ASSIGN(left = e1, right = e2)::rest)
equation
e1 = Expression.crefExp(cr);
//e1 = Expression.crefExp(cr);
outRow = incidenceRowExp(e1, inVariables, inRow, functionTree, inIndexType);
outRow = incidenceRowExp(e2, inVariables, outRow, functionTree, inIndexType);
outRow = incidenceRowWhenOps(rest, inVariables, inIndexType, functionTree, outRow);
Expand Down Expand Up @@ -4377,16 +4377,30 @@ algorithm
_ := match(rs)
local
Integer varIndx;
list<Integer> varIdcs;
DAE.ComponentRef left;
list<DAE.ComponentRef> crefs;
DAE.Exp right, leftexp;

case BackendDAE.ASSIGN(left, right) equation
case BackendDAE.ASSIGN(left = leftexp as DAE.CREF(componentRef = left), right=right)
equation
(_,{varIndx}) = BackendVariable.getVar(left, vars);
varsSolvedInWhenEqns = varIndx :: varsSolvedInWhenEqns;
lst = adjacencyRowExpEnhanced(right, vars, mark, rowmark, lst);
// mark all negative because the when condition cannot used to solve a variable
_ = List.fold1(lst,markNegativ,rowmark,mark);
leftexp = Expression.crefExp(left);
//leftexp = Expression.crefExp(left);
lst = adjacencyRowExpEnhanced(leftexp, vars, mark, rowmark, lst);
outRow = adjacencyRowEnhanced1(lst,leftexp,right,vars,globalKnownVars,mark,rowmark,outRow,false);
then ();

case BackendDAE.ASSIGN(leftexp, right) equation
crefs = Expression.getAllCrefs(leftexp);
(_,varIdcs) = BackendVariable.getVarLst(crefs, vars);
varsSolvedInWhenEqns = listAppend(varIdcs, varsSolvedInWhenEqns);
lst = adjacencyRowExpEnhanced(right, vars, mark, rowmark, lst);
// mark all negative because the when condition cannot used to solve a variable
_ = List.fold1(lst,markNegativ,rowmark,mark);
lst = adjacencyRowExpEnhanced(leftexp, vars, mark, rowmark, lst);
outRow = adjacencyRowEnhanced1(lst,leftexp,right,vars,globalKnownVars,mark,rowmark,outRow,false);
then ();
Expand Down
4 changes: 2 additions & 2 deletions Compiler/BackEnd/BackendDump.mo
View file
Expand Up @@ -2010,9 +2010,9 @@ algorithm
DAE.Exp e,e1;
Absyn.Path functionName;
list<DAE.Exp> functionArgs;
case BackendDAE.ASSIGN(left=cr, right=e)
case BackendDAE.ASSIGN(left=e1, right=e)
equation
scr = ComponentReference.printComponentRefStr(cr);
scr = ExpressionDump.printExpStr(e1);
se = ExpressionDump.printExpStr(e);
str = stringAppendList({scr," := ",se});
then
Expand Down
26 changes: 16 additions & 10 deletions Compiler/BackEnd/BackendEquation.mo
View file
Expand Up @@ -145,7 +145,11 @@ public function getWhenEquationExpr "Get the left and right hand parts from an e
output DAE.ComponentRef outComponentRef;
output DAE.Exp outExp;
algorithm
BackendDAE.WHEN_STMTS(whenStmtLst={BackendDAE.ASSIGN(left=outComponentRef, right=outExp)}) := inWhenEquation;
try
BackendDAE.WHEN_STMTS(whenStmtLst={BackendDAE.ASSIGN(left=DAE.CREF(componentRef = outComponentRef), right=outExp)}) := inWhenEquation;
else
print("getWhenEQuationExpr failed\n");
end try;
end getWhenEquationExpr;

public function setWhenElsePart
Expand Down Expand Up @@ -887,18 +891,20 @@ algorithm
DAE.ElementSource source;

case {} then (listReverse(inAccum),inTypeA);
case (BackendDAE.ASSIGN(left = cr, right = e2, source = source)::rest)
case (BackendDAE.ASSIGN(left = e1, right = e2, source = source)::rest)
equation
tp = Expression.typeof(e2);
e1 = Expression.makeCrefExp(cr, tp);
//e1 = Expression.makeCrefExp(cr, tp);
(e1, extArg) = inFunc(e1, inTypeA);
/*
if Expression.isCref(e1) then
DAE.CREF(cr1, _) = e1;
else
cr1=cr;
end if;
*/
(e2, extArg) = inFunc(e2, extArg);
(outWhenOps, extArg) = traverseExpsOfWhenOps(rest, inFunc, extArg, BackendDAE.ASSIGN(cr1, e2, source)::inAccum);
(outWhenOps, extArg) = traverseExpsOfWhenOps(rest, inFunc, extArg, BackendDAE.ASSIGN(e1, e2, source)::inAccum);
then (outWhenOps, extArg);
case (BackendDAE.REINIT(stateVar = cr, value = e2, source = source)::rest)
equation
Expand Down Expand Up @@ -1026,10 +1032,10 @@ algorithm
Boolean b;

case {} then (inCont,inTypeA);
case (BackendDAE.ASSIGN(left = cr, right = e2)::rest)
case (BackendDAE.ASSIGN(left = e1, right = e2)::rest)
equation
tp = Expression.typeof(e2);
e1 = Expression.makeCrefExp(cr, tp);
//e1 = Expression.makeCrefExp(cr, tp);
if inCont then
(_, b, extArg) = inFunc(e1, inTypeA);
end if;
Expand Down Expand Up @@ -1319,8 +1325,8 @@ algorithm
res = List.isEqualOnTrue(explst1, explst2, Expression.expEqual);
then res;

case (BackendDAE.WHEN_EQUATION(whenEquation = BackendDAE.WHEN_STMTS(whenStmtLst={BackendDAE.ASSIGN(left=cr1, right=exp1)})), BackendDAE.WHEN_EQUATION(whenEquation = BackendDAE.WHEN_STMTS(whenStmtLst={BackendDAE.ASSIGN(left=cr2, right=exp2)}))) equation
res = boolAnd(ComponentReference.crefEqualNoStringCompare(cr1, cr2), Expression.expEqual(exp1, exp2));
case (BackendDAE.WHEN_EQUATION(whenEquation = BackendDAE.WHEN_STMTS(whenStmtLst={BackendDAE.ASSIGN(left=e11, right=e12)})), BackendDAE.WHEN_EQUATION(whenEquation = BackendDAE.WHEN_STMTS(whenStmtLst={BackendDAE.ASSIGN(left=e21, right=e22)}))) equation
res = boolAnd(Expression.expEqual(e11, e21), Expression.expEqual(e12, e22));
then res;

else false;
Expand Down Expand Up @@ -3222,8 +3228,8 @@ algorithm
then Expression.crefExp(cref);
case(BackendDAE.COMPLEX_EQUATION(left = exp1))
then exp1;
case(BackendDAE.WHEN_EQUATION(whenEquation=BackendDAE.WHEN_STMTS(condition=DAE.BCONST(bool=true),whenStmtLst={BackendDAE.ASSIGN(left=cref)})))
then Expression.crefExp(cref);
case(BackendDAE.WHEN_EQUATION(whenEquation=BackendDAE.WHEN_STMTS(condition=DAE.BCONST(bool=true),whenStmtLst={BackendDAE.ASSIGN(left=exp1)})))
then exp1;
else
//equation print("BackendEquation.getEquationLHS failed!\n");
then fail();
Expand Down
4 changes: 2 additions & 2 deletions Compiler/BackEnd/BackendInline.mo
View file
Expand Up @@ -390,10 +390,10 @@ algorithm
list<BackendDAE.WhenOperator> rest;
DAE.ElementSource source;

case BackendDAE.ASSIGN(left = cr, right = e2, source = source)
case BackendDAE.ASSIGN(left = e1, right = e2, source = source)
equation
(e2, source, b,_) = Inline.inlineExp(e2, fns, source);
outWhenOps = (if b then BackendDAE.ASSIGN(cr, e2, source) else whenOp)::outWhenOps;
outWhenOps = (if b then BackendDAE.ASSIGN(e1, e2, source) else whenOp)::outWhenOps;
inlined = inlined or b;
then ();

Expand Down
20 changes: 17 additions & 3 deletions Compiler/BackEnd/BackendVarTransform.mo
View file
Expand Up @@ -1937,17 +1937,31 @@ algorithm

case ({},_,_,_,_) then (listReverse(iAcc),replacementPerformed);

case ((wop as BackendDAE.ASSIGN(left=cr,right=exp,source=source))::res,_,_,_,_)
case ((wop as BackendDAE.ASSIGN(left=cre as DAE.CREF(componentRef = cr),right=exp,source=source))::res,_,_,_,_)
equation
cre = Expression.crefExp(cr);
//cre = Expression.crefExp(cr);
(cre1,b1) = replaceExp(cre,repl,inFuncTypeExpExpToBooleanOption);
(cr1,_) = validWhenLeftHandSide(cre1,cre,cr);
source = ElementSource.addSymbolicTransformationSubstitution(b1,source,cre,cre1);
(exp1,b2) = replaceExp(exp,repl,inFuncTypeExpExpToBooleanOption);
(exp1,_) = ExpressionSimplify.condsimplify(b2,exp1);
source = ElementSource.addSymbolicTransformationSubstitution(b2,source,exp,exp1);
b = b1 or b2;
wop1 = if b then BackendDAE.ASSIGN(cr1,exp1,source) else wop;
wop1 = if b then BackendDAE.ASSIGN(cre1,exp1,source) else wop;
(res1,b) = replaceWhenOperator(res,repl,inFuncTypeExpExpToBooleanOption,replacementPerformed or b,wop1::iAcc);
then
(res1,b);

case ((wop as BackendDAE.ASSIGN(left=cre, right=exp, source=source))::res,_,_,_,_)
equation
//cre = Expression.crefExp(cr);
(cre1,b1) = replaceExp(cre,repl,inFuncTypeExpExpToBooleanOption);
source = ElementSource.addSymbolicTransformationSubstitution(b1,source,cre,cre1);
(exp1,b2) = replaceExp(exp,repl,inFuncTypeExpExpToBooleanOption);
(exp1,_) = ExpressionSimplify.condsimplify(b2,exp1);
source = ElementSource.addSymbolicTransformationSubstitution(b2,source,exp,exp1);
b = b1 or b2;
wop1 = if b then BackendDAE.ASSIGN(cre1,exp1,source) else wop;
(res1,b) = replaceWhenOperator(res,repl,inFuncTypeExpExpToBooleanOption,replacementPerformed or b,wop1::iAcc);
then
(res1,b);
Expand Down
4 changes: 2 additions & 2 deletions Compiler/BackEnd/DAEQuery.mo
View file
Expand Up @@ -136,9 +136,9 @@ algorithm
then
res;

case (BackendDAE.WHEN_EQUATION(whenEquation = BackendDAE.WHEN_STMTS(condition=condition,whenStmtLst={BackendDAE.ASSIGN(left = cr,right = e2)})))
case (BackendDAE.WHEN_EQUATION(whenEquation = BackendDAE.WHEN_STMTS(condition=condition,whenStmtLst={BackendDAE.ASSIGN(left = e1,right = e2)})))
equation
s1 = ComponentReference.printComponentRefStr(cr);
s1 = ExpressionDump.printExpStr(e1);
s2 = ExpressionDump.printExpStr(e2);
s3 = ExpressionDump.printExpStr(condition);
res = stringAppendList({"'when ", s3, " then " , s1," = ",s2,"; end when;'"});
Expand Down

0 comments on commit 1692f27

Please sign in to comment.