- Added pretty-printing of the cases in match-expressions (which used to be ignored)

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

Author: sjoelund

Compiler/BackEnd/BackendDAEUtil.mo

@@ -2598,17 +2598,16 @@ protected
   String keystr;
 algorithm
   keystr := ComponentReference.printComponentRefStr(key);
-  v := treeGet2(bt, keystr);
+  v := treeGet3(bt, keystr, treeGet2(bt, keystr));
 end treeGet;
 
-protected function treeGet2 "function: treeGet2
-  author: PA
-  Helper function to treeGet"
+protected function treeGet2
+  "Helper function to treeGet"
   input BackendDAE.BinTree inBinTree;
   input String inString;
-  output BackendDAE.Value outValue;
+  output Integer compResult;
 algorithm
-  outValue := match (inBinTree,inString)
+  compResult := match (inBinTree,inString)
     local
       String rkeystr,keystr;
       DAE.ComponentRef rkey;
@@ -2620,7 +2619,7 @@ algorithm
     case (BackendDAE.TREENODE(value = SOME(BackendDAE.TREEVALUE(key=rkey))),keystr)
       equation
         rkeystr = ComponentReference.printComponentRefStr(rkey);
-      then treeGet3(inBinTree, keystr, stringCompare(rkeystr, keystr));
+      then stringCompare(rkeystr, keystr);
   end match;
 end treeGet2;
 
@@ -2643,10 +2642,14 @@ algorithm
     case (BackendDAE.TREENODE(value = SOME(BackendDAE.TREEVALUE(value=rval))),keystr,0) then rval;
     // search right
     case (BackendDAE.TREENODE(rightSubTree = SOME(right)),keystr,1)
-      then treeGet2(right, keystr);
+      equation
+        compResult = treeGet2(right, keystr);
+      then treeGet3(right, keystr, compResult);
     // search left
     case (BackendDAE.TREENODE(leftSubTree = SOME(left)),keystr,-1)
-      then treeGet2(left, keystr);
+      equation
+        compResult = treeGet2(left, keystr); 
+      then treeGet3(left, keystr, compResult);
   end match;
 end treeGet3;
 

Compiler/FrontEnd/DAEDump.mo

@@ -1718,8 +1718,8 @@ algorithm
    end matchcontinue;
 end ppWhenStmtStr;
 
-protected function ppStmtStr "function: ppStmtStr
-  Helper function to ppStatementStr"
+public function ppStmtStr
+  "Helper function to ppStatementStr"
   input DAE.Statement inStatement;
   input Integer inInteger;
   output String outString;
@@ -1735,52 +1735,41 @@ algorithm
       list<DAE.Statement> then_,stmts;
       DAE.Statement stmt;
       Algorithm.Else else_;
+      DAE.Pattern pat;
 
     case (DAE.STMT_ASSIGN(exp1 = e2 as DAE.CREF(c,_),exp = e),i)
       equation
         s1 = indentStr(i);
         s2 = ComponentReference.printComponentRefStr(c);
-        s3 = stringAppend(s1, s2);
-        s4 = stringAppend(s3, " := ");
-        s5 = ExpressionDump.printExpStr(e);
-        s6 = stringAppend(s4, s5);
-        str = stringAppend(s6, ";\n");
+        s3 = ExpressionDump.printExpStr(e);
+        str = stringAppendList({s1,s2," := ",s3,";\n"});
       then
         str;
 
     case (DAE.STMT_ASSIGN(exp1 = e2 as DAE.ARRAY(array=_),exp = e),i)
       equation
         s1 = indentStr(i);
         s2 = ExpressionDump.printExpStr(e2);
-        s3 = stringAppend(s1, s2);
-        s4 = stringAppend(s3, " := ");
-        s5 = ExpressionDump.printExpStr(e);
-        s6 = stringAppend(s4, s5);
-        str = stringAppend(s6, ";\n");
+        s3 = ExpressionDump.printExpStr(e);
+        str = stringAppendList({s1,s2," := ",s3,";\n"});
       then
         str;
 
     case (DAE.STMT_ASSIGN(exp1 = e2 as DAE.ASUB(_,_),exp = e),i)
       equation
         s1 = indentStr(i);
         s2 = ExpressionDump.printExpStr(e2);
-        s3 = stringAppend(s1, s2);
-        s4 = stringAppend(s3, " := ");
-        s5 = ExpressionDump.printExpStr(e);
-        s6 = stringAppend(s4, s5);
-        str = stringAppend(s6, ";\n");
+        s3 = ExpressionDump.printExpStr(e);
+        str = stringAppendList({s1,s2," := ",s3,";\n"});
       then
         str;
 
     case (DAE.STMT_ASSIGN_ARR(componentRef = c,exp = e),i)
       equation
         s1 = indentStr(i);
         s2 = ComponentReference.printComponentRefStr(c);
-        s3 = stringAppend(s1, s2);
-        s4 = stringAppend(s3, " := ");
-        s5 = ExpressionDump.printExpStr(e);
-        s6 = stringAppend(s4, s5);
-        str = stringAppend(s6, ";\n");
+        s3 = ExpressionDump.printExpStr(e);
+        str = stringAppendList({s1,s2," := ",s3,";\n"});
       then
         str;
 
@@ -1893,7 +1882,22 @@ algorithm
         e2_str = ExpressionDump.printExpStr(e2);
         str = stringAppendList({s1,"reinit(",e1_str,", ",e2_str,");\n"});
       then str;
-    
+        
+    case (DAE.STMT_FAILURE(body=stmts),i)
+      equation
+        s1 = indentStr(i);
+        s2 = ppStmtListStr(stmts, i+2);
+        str = stringAppendList({s1,"failure(\n",s2,s1,");\n"});
+      then str;
+        
+    case (DAE.STMT_ASSIGN_PATTERN(lhs=pat, rhs=e),i)
+      equation
+        s1 = indentStr(i);
+        s2 = Patternm.patternStr(pat);
+        s3 = ExpressionDump.printExpStr(e);
+        str = stringAppendList({s1,s2," := ",s3,";\n"});
+      then str;
+
     case (_,i)
       equation
         s1 = indentStr(i);

Compiler/FrontEnd/ExpressionDump.mo

@@ -55,8 +55,10 @@ public type Var = DAE.ExpVar;
 
 // protected imports
 protected import ComponentReference;
+protected import DAEDump;
 protected import Dump;
 protected import Expression;
+protected import Patternm;
 protected import RTOpts;
 protected import Util;
 protected import Print;
@@ -566,6 +568,7 @@ algorithm
       list<list<tuple<DAE.Exp, Boolean>>> lstes;
       Absyn.MatchType matchTy;
       DAE.ExpType et;
+      list<DAE.MatchCase> cases;
 
     case (DAE.END(), _, _, _) then "end";
 
@@ -890,11 +893,12 @@ algorithm
       then
         s;
 
-    case (DAE.MATCHEXPRESSION(matchType=matchTy,inputs=es), _, _, _)
+    case (DAE.MATCHEXPRESSION(matchType=matchTy,inputs=es,cases=cases), _, _, _)
       equation
         s1 = Dump.printMatchType(matchTy);
         s2 = printExp2Str(DAE.TUPLE(es), stringDelimiter, opcreffunc, opcallfunc);
-        s = stringAppendList({s1,s2,"\n","#cases#\n","end ",s1});
+        s3 = stringAppendList(Util.listMap(cases,printCase2Str));
+        s = stringAppendList({s1,s2,s3,"end ",s1});
       then s;
 
     case (DAE.SHARED_LITERAL(index=i,ty=et), _, _, _)
@@ -912,6 +916,31 @@ algorithm
   end matchcontinue;
 end printExp2Str;
 
+protected function printCase2Str
+  "Prints a matchcase as string"
+  input DAE.MatchCase matchCase;
+  output String str;
+algorithm
+  str := match matchCase
+    local
+      list<DAE.Pattern> patterns;
+      list<DAE.Statement> body;
+      Option<DAE.Exp> result;
+      String resultStr,patternsStr,bodyStr;
+    case DAE.CASE(patterns=patterns, body={}, result=result)
+      equation
+        patternsStr = Patternm.patternStr(DAE.PAT_META_TUPLE(patterns));
+        resultStr = Util.getOptionOrDefault(Util.applyOption(result, printExpStr), "fail()");
+      then stringAppendList({"    case ",patternsStr," then ",resultStr,";\n"});
+    case DAE.CASE(patterns=patterns, body=body, result=result)
+      equation
+        patternsStr = Patternm.patternStr(DAE.PAT_META_TUPLE(patterns));
+        resultStr = Util.getOptionOrDefault(Util.applyOption(result, printExpStr), "fail()");
+        bodyStr = stringAppendList(Util.listMap1(body, DAEDump.ppStmtStr, 8));
+      then stringAppendList({"    case ",patternsStr,"\n      algorithm\n",bodyStr,"      then ",resultStr,";\n"});
+  end match;
+end printCase2Str;
+
 public function expPriority
 "function: expPriority
  Returns a priority number for an expression.
@@ -1750,6 +1779,7 @@ algorithm
       DAE.Exp ae1;
       Boolean b;
       Absyn.MatchType matchTy;
+      list<DAE.MatchCase> cases;
 
     case (DAE.ICONST(integer = i),_)
       equation
@@ -2069,13 +2099,13 @@ algorithm
       then
         ();
 
-    case (DAE.MATCHEXPRESSION(matchType=matchTy,inputs=es), _)
+    case (DAE.MATCHEXPRESSION(matchType=matchTy,inputs=es,cases=cases), _)
       equation
         Print.printBuf(Dump.printMatchType(matchTy));
         Print.printBuf(" (");
         printList(es, printExp, ",");
         Print.printBuf(") \n");
-        Print.printBuf("    #cases#\n");
+        Print.printBuf(stringAppendList(Util.listMap(cases,printCase2Str)));
         Print.printBuf("  end ");
         Print.printBuf(Dump.printMatchType(matchTy));
       then ();

Compiler/FrontEnd/Patternm.mo

@@ -460,22 +460,36 @@ algorithm
       DAE.Pattern pat,head,tail;
       String id;
       DAE.ExpType et;
+      Absyn.Path name;
     case DAE.PAT_WILD() then "_";
-    case DAE.PAT_AS(id,_,DAE.PAT_WILD()) then id;
+    case DAE.PAT_AS(id=id,pat=DAE.PAT_WILD()) then id;
+    case DAE.PAT_AS_FUNC_PTR(id,DAE.PAT_WILD()) then id;
     case DAE.PAT_SOME(pat)
       equation
         str = patternStr(pat);
       then "SOME(" +& str +& ")";
     case DAE.PAT_META_TUPLE(pats)
       equation
         str = Util.stringDelimitList(Util.listMap(pats,patternStr),",");
-      then "Tuple(" +& str +& ")";
+      then "(" +& str +& ")";
+        
+    case DAE.PAT_CALL_TUPLE(pats)
+      equation
+        str = Util.stringDelimitList(Util.listMap(pats,patternStr),",");
+      then "(" +& str +& ")";
+    
+    case DAE.PAT_CALL(name=name, patterns=pats)
+      equation
+        id = Absyn.pathString(name);
+        str = Util.stringDelimitList(Util.listMap(pats,patternStr),",");
+      then stringAppendList({id,"(",str,")"});
 
     case DAE.PAT_CONS(head,tail) then patternStr(head) +& "::" +& patternStr(tail);
 
-    case DAE.PAT_CONSTANT(_,exp) then ExpressionDump.printExpStr(exp);
+    case DAE.PAT_CONSTANT(exp=exp) then ExpressionDump.printExpStr(exp);
     // case DAE.PAT_CONSTANT(SOME(et),exp) then "(" +& ExpressionDump.typeString(et) +& ")" +& ExpressionDump.printExpStr(exp);
-    case DAE.PAT_AS(id,_,pat) then id +& " as " +& patternStr(pat);
+    case DAE.PAT_AS(id=id,pat=pat) then id +& " as " +& patternStr(pat);
+    case DAE.PAT_AS_FUNC_PTR(id, pat) then id +& " as " +& patternStr(pat);
     else
       equation
         Error.addMessage(Error.INTERNAL_ERROR, {"Patternm.patternStr not implemented correctly"});